text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Feathers — UI фреймворк на основе Starling для мобильных и десктоп приложений
Поводом, для написания данного поста, послужил выход новой версии **[UI фреймворка Feathers](http://feathersui.com).**
Являясь AS3 разработчиком, я слежу за развитием данного продукта начиная с ранних бета версий. На данном этапе развития этого продукта, можно с увереностью утверждать, что он готов к массовому использованию. А не только в кругу комьюнити и Flash энтузиастов.
**Feathers** это библиотека компонентов пользовательского интерфейса использующая все возможности GPU ускорения через [Starling](http://gamua.com/starling/) фреймворк. Библиотека содержащая в себе быстрые, легковесные и легко расширяемые UI контроллы для мобильных и десктопных приложений.
Feathers имеет открытый код и поддерживается комьюнити разработчиков с одной стороны и Adobe с другой. Такой симбиоз обеспечивает идеальные условия для развития продукта, «когда верхи могут а низы хотят». Технически данный фреймворк опирается на прочный и зарекомендовавший себя фундамент Starling. Про который обязательно стоит сказать несколько слов, для понимания общей картины и силы данного фреймворка.
##### Что такое Starling?
Starling это AS3 фреймворк разработанный на основе Stage3D, для 2D приложений. Изначально Starling позиционировался как средство для разработки игр, но оказалось, что его можно использовать для решения многих других задач. Особенно, задач в которых важна скорость приложения, ведь Starling позволяет быстро создавать аппаратно ускоренные приложения. Фактически Starling позволяет использовать GPU ускорение без необходимости писать высокоуровневые библиотеки и разбираться в низкоуровневом API Stage3D.
Фреймворк Starling разработан с оглядкой на API Flash Player, он обеспечивает отличный уровень абстракции от API Stage3D, и в то же время использует структуры знакомые AS3 разработчику. Время вхождения, даже для начинающего AS3 разработчика, минимально.
Обобщая сказанное получаем отличное, продуманное средство для написания игр, в минимальные сроки, на разные платформы и чтоб не тормозило. Игры на Starling получаются просто отличные, думаю, в [птичек от Rovio](http://gamua.com/blog/2012/02/angry-birds-powered-by-starling-framework/) играл каждый.
А только ли игры? Ну можно и не игры, но тогда UI более консервативно рисовать нужно, кнопочки, списки, слайдеры, чекбоксы, галереи. Как то это всё скиновать под устройства. Что тут сказать, человек по природе своей очень ленив и, было бы странно, не получить на основе Starling решение для быстрого построения UI приложений.
##### Stage3D UI от Feathers
Начиная с ранних бета версий фреймворка, я пробовал его использовать в своих приложениях, например, в игре [Чудесные Наклейки](https://itunes.apple.com/ru/app/cudesnye-naklejki/id620957010) кнопочки и список айтемов наклеек сделан с использованием Feathers. Не менее увлекательные примеры [можно найти на сайте фреймворка](http://feathersui.com/showcase/).
Для AS3 разработчика старт использования фреймворка быстрый и безболезненный. Добавляем библиотеки в проект и переходим к коду.
Результатом хочется получить некоторого вида Hello World:
Предположим, что вы уже знаете как использовать и инициализировать Starling, и сразу перейдём к Feathers. Ниже приведён пример класса Main, который мы будем использовать как корневой дисплей листа Starling.
```
package feathers.examples.helloWorld
{
import feathers.controls.Button;
import feathers.controls.Callout;
import feathers.controls.Label;
import feathers.themes.MetalWorksMobileTheme;
import starling.display.Sprite;
import starling.event.Event;
public class Main extends Sprite
{
public function Main()
{
this.addEventListener( Event.ADDED_TO_STAGE, addedToStageHandler );
}
protected var button:Button;
protected function addedToStageHandler( event:Event ):void
{
}
}
}
```
Далее большая часть кода будет в обработчике `addedToStageHandler()`.
Первым делом отпишемся от события `ADDED_TO_STAGE` и добавим инициализацию темы:
```
protected function addedToStageHandler(event:Event):void
{
this.removeEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
new MetalWorksMobileTheme();
}
```
Слушатель темы мониторит момент добавления компонентов в дисплей лист, и каждый раз при добавление UI объекта применяет соответствующий скин. Примеры построения уникальных тем можно найти в документации к фреймворку. На их основе можно быстро создать свою тему.
Теперь добавим кнопку [Button](http://wiki.starling-framework.org/feathers/button):
```
this.button = new Button();
this.button.label = "Click Me";
this.addChild( button );
```
И обработчик тапа/клика:
```
this.button.addEventListener( Event.TRIGGERED, button_triggeredHandler );
```
В обработчике события клика добавим появление вплывающего компонента [Callout](http://wiki.starling-framework.org/feathers/callout):
```
protected function button_triggeredHandler( event:Event ):void
{
const label:Label = new Label();
label.text = "Hi, I'm Feathers!\nHave a nice day.";
Callout.show( label, this.button );
}
```
Следует заметить что Feathers имеет систему валидации перерисовки, это позволяет перерисовывать объекты только тогда, когда это необходимо. В случае, если мы применяем несколько свойств к объекту то можем значительно сэкономить перерисовав объект только один раз.
В данном случае ни одно свойство не было применено к нашей кнопке, вызовем валидацию принудительно:
```
this.button.validate();
```
И центрируем нашу кнопку:
```
this.button.x = (this.stage.stageWidth - this.button.width) / 2;
this.button.y = (this.stage.stageHeight - this.button.height) / 2;
```
Что получилось [можно посмотреть тут](http://feathersui.com/examples/hello-world/).
В итоге, мы имеем инструмент разработки, по скорости сравнимый с нативными решениями. Имеющий покрытие платформ, не меньше, чем у фреймворков для гибридных HTML5 JS приложений. (Особенно, учитывая факт того, что [Starling имеет планы по покрытию JS направления](http://gamua.com/area-51/).) И явно заслуживающий стратегического внимания разработчиков кроссплатформенных мобильных приложений. | https://habr.com/ru/post/184232/ | null | ru | null |
# Заметка: Контроль звуковых выходов для программ
Иногда надо иметь отдельный виртуальный "выход" для звука из некоторых программ. Например, на стриме через OBS. Эта программа не поддерживает такое "нативно", но это возможно сделать с помощью PulseAudio.
Делается это с помощью `null sinks` и `модуля loopback`, про которые я немножко расскажу.
Понадоблятся утилиты `pactl` и `pavucontrol`, которые должны быть установлены.
Первый шаг. Создание Sink
-------------------------
В PulseAudio есть такая вещь, как **sinks**, которые представляют собой **выходы** для звука. Нам нужен такой, чтобы не был привязан к наушникам или ещё чему-то. Создаётся такой командой:
```
pactl load-module module-null-sink sink_name="web_sink" sink_properties=device.description="a sink for the web browser"
```
Мы вызываем утилиту `pactl`, чтобы создать так называемый `null sink`, который представлен отдельным модулем в PulseAudio. Ему мы передаём параметры:
* название sink: я выбрал `web_sink`, так как использовать буду для Firefox;
* настройки:
* + описание: тут всё понятно с названия, `a sink for the web browser`
Это то что нам надо — **sink** (выход), **не** привязанный к устройству.
Шаг второй. Перенаправление
---------------------------
Теперь нам нужен `pavucontrol`, чтобы назначить приложению данный sink.
**Предупреждение: это НОРМАЛЬНО, что вы не будете слышать звук из того приложение, которое выбрали!**
Открываем `pavucontrol` и видим список приложений с настройками громкости и sink-ами:
Теперь, проскроллим к тому приложению, которому надо переназначить выход. Нажимаем на кнопку, где сейчас написано название устройства выхода, и выбираем нужный sink в выпадающем меню.
Как я уже сказал, его не будет слышно — это знак того, что вы сделали всё правильно.
Третий (последний) шаг. Возвращение звука
-----------------------------------------
Для "подключения" null sink к наушникам, используется модуль `loopback`, который только этим и занимается.
Сначала, надо узнать, как сам PulseAudio называет это устройство. Для этого выполняем команду:
```
pactl list short sinks
```
Надо найти строку, где в конце пишет `RUNNING`, и получить оттуда название (у меня оно выглядит как-то так: `alsa_output.INTERFACE-NAME.analog-[stereo/mono]`).
Потом загружаем нужный модуль, и не забываем проставить правильные названия sink-ов:
```
pactl load-module module-loopback source="web_sink".monitor sink="OUTPUTDEVICENAME"
```
Теперь должно быть всё слышно. А если зайти в тот же OBS, sink `web` должен появиться в списке устройств выхода звука. | https://habr.com/ru/post/565816/ | null | ru | null |
# Terminal Keynote – показываем презентации в терминале
Terminal Keynote – это, скрипт, созданный Хавьером Нориа (Xavier Noria) для показа своих презентаций на BaRuCo 2012 и RailsClub 2012. Вся его суть в возможности показывать слайды с текстом прямо в терминале.
Здесь нет никакого встроенного форматирования. Для использования жирного шрифта или цветов придётся использовать символы ANSI. Нужен простой список? Символ " \* " вам в помощь.
Есть 4 типа слайдов.
:code
-----
Слайд с исходным кодом, код подсвечивается на лету. Нужно поместить на слайд название файла или ещё что-то? Используйте комментарии и воображение.
Вот код этого слайда:
```
slide <<-EOS, :code
# rubinius/kernel/common/module.rb
class Module
attr_reader :constant_table
attr_writer :method_table
...
end
EOS
```
:center
-------
В таких слайдах текст линия за линией выравниватся по центру.
Исходный код:
```
slide <<-EOS, :center
Corollary: Active Support does not emulate
constant name resolution algorithms
EOS
```
:block
------
Форматирование сохраняется, весь текст целиком выравнивается по центру.
```
slide <<-EOS, :block
What is watched and reloaded:
* Routes
* Locales
* Application files:
- Ruby files under autoload_*
- db/(schema.rb|structure.sql)
EOS
```
sections
--------
Секции – заголовки к группам слайдов.
Написать их можно так:
```
section "Constants Refresher" do
...
end
```
Визуальные эффекты
------------------
Эффект тут всего один. Все символы на слайде выводятся друг за другом с разницей в несколько миллисекунд. Выглядит как олдскульный курсор.
### Управление слайдами
Пробел, «n», «k», «l» или PageDown ("\e[5~") – переход к следующему слайду.
«b», «p», «h», «j», PageUp ("\e[6~") – переход к предыдущему слайду.
"^" – перейти на самый первый слайд, "$" – на самый последний.
«q» – выход.
Шрифт и размер терминала
------------------------
Автор изспользует шрифт Menlo размера 32, это даёт терминал 18x52 при разрешении 1024х768.
Установка
---------
Для установки нужен Ruby 1.9 и [Pygments](http://pygments.org/).
Просто
После установки пример презентации можно запустить вот так:
```
bundle exec bin/tkn examples/constant_autoloading_in_ruby_on_rails.rb
```
Есть сниппет для создания слайдов в Sublime Text 2.
### Ссылки
Репозиторий на Github: <https://github.com/fxn/tkn> | https://habr.com/ru/post/151512/ | null | ru | null |
# Tarantool vs Redis: что умеют in-memory технологии
В этой статье я хочу сравнить Redis и Tarantool. У меня нет цели сделать громогласный вывод «Tarantool лучше!» или «Redis круче!». Я хочу понять их сходства и отличия, разобраться, для каких задач какую технологию выбрать. Потому что это очень близкие на первый взгляд вещи, и вопросы про их отличия я вижу часто.
Для этого мы посмотрим на технологии в трёх частях:
* Вначале посмотрим глазами новичка. Что такое БД в памяти? Какие задачи они решают лучше дисковых БД?
* Потом посмотрим архитектурно. Как обстоит вопрос с производительностью, надёжностью, масштабированием?
* В третьей части лезем в технические вещи поглубже. Типы данных, итераторы, индексы, транзакции, ЯП, репликация, коннекторы.
Смело переходите сразу к наиболее интересной вам части. Или даже сразу к итоговой табличке сравнения, которую я прикладываю в заключении.
Поехали!
Содержание
----------
1. Вводная часть
* Что такое БД в памяти
* Зачем нужны решения в памяти
* Что такое Redis
* Что такое Tarantool
2. Архитектурная часть
* Производительность
* Надёжность
* Масштабируемость
* Валидация схемы данных
3. Технические особенности
* Какие типы данных можно хранить
* Вытеснение данных
* Итерация по ключам
* Вторичные индексы
* Транзакции
* Персистентность
* Язык программирования для хранимых процедур
* Репликация
* Коннекторы из других языков программирования
* Под какие задачи плохо подходят
* Экосистема
* Чем Redis лучше
* Чем Tarantool лучше
4. Вывод
5. Ссылки
1. Вводная часть
----------------
### Что такое БД в памяти
Redis и Tarantool — это in-memory технологии. Их ещё называют «резидентными БД», но я буду писать короче — «в памяти» или in-memory. Так что такое БД в памяти?
Это база, которая весь объём данных хранит целиком в оперативной памяти. Размер такой базы лимитирован ёмкостью оперативной памяти узла, что может ограничивать нас в количестве данных, но увеличивает скорость на порядок.
Если данных слишком много, БД в памяти способны сохранять данные на диск. Можно перезагрузить узел и не потерять информацию. Стереотип про ненадёжность БД в памяти сильно устарел, их можно использовать как основное хранилище в production. Например, Mail.ru Cloud Solutions использует Tarantool как основную БД для хранения метаинформации в своём объектном хранилище [1].
БД в памяти нужны для высокой скорости доступа к данным, условно от 10 000 запросов в секунду. Например, запросы к ленте новостей Кинопоиска в день релиза Снайдерката «Лиги Справедливости», Яндекс.Маркет перед Новым Годом или Delivery Club вечером в пятницу.
### Зачем нужны решения в памяти
**Кеш**. БД в памяти традиционно используют как кеш для более медленных баз данных. Это логично, память быстрее диска (даже SSD). Но в жизненном цикле любого кеша случаются перезагрузки, падения, сетевая недоступность, нехватка памяти и прочие инфраструктурные беды.
С течением времени кеши стали уметь в персистентность, резервирование и шардирование.
* **Персистентность** — кеши сохраняют данные на диск. После перезагрузки восстанавливаем своё состояние без обращений к основному хранилищу. Если этого не делать, то обращение к холодному кешу будет очень долгим или даже положит основную БД.
* **Резервирование** — кеши содержат функции репликации данных. Если упал один узел, то второй возьмёт на себя запросы. Основное хранилище не упадёт от перегруза, нас спасает резервная нода.
* **Шардирование** — если горячие данные не помещаются в оперативную память одного узла, мы используем несколько узлов параллельно. Это горизонтальное масштабирование.
Шардирование — это большая система. Резервирование — это надёжная система. Вместе с персистентностью получается *кластерное хранилище данных*. Можно положить туда терабайты информации и крутить их на скорости 1 000 000 RPS.
**OLTP**. Расшифровывается как Online Transaction Processing, обработка транзакций в реальном времени. In-memory решения подходят для такого типа задач благодаря своей архитектуре. OLTP — это большое количество коротких on-line транзакций (INSERT, UPDATE, DELETE). Главное в OLTP-системах — быстро обработать запросы и обеспечить целостность данных. Эффективность чаще всего определяется количеством RPS.
### Что такое Redis
* Redis называет себя «in-memory хранилище структур данных».
* Redis — это key-value.
* Больше всего известен по кешированию дисковых баз. Если вы будете искать по ключевым словам «кеширование баз данных», то в каждой статье найдёте упоминания Redis.
* Redis поддерживает первичные индексы, не поддерживает вторичные.
* Redis содержит в себе механизм хранимых процедур на Lua.
### Что такое Tarantool
* Tarantool называет себя «платформа для in-memory вычислений».
* Tarantool умеет в key-value. А еще в документы и реляционную модель данных.
* Создан для горячих данных — кеширования MySQL в соцсети. С течением времени развился в полноценную базу данных.
* Tarantool может строить произвольное количество индексов по данным.
* В Tarantool тоже можно написать хранимую процедуру и тоже на Lua.
Разобрались с основами, давайте переходить на следующий уровень.
2. Архитектурная часть
----------------------
### Производительность
Это самый любимый запрос про БД в памяти — а насколько вы быстрые? «Сколько миллионов РПС можно снять с одного ядра?» Проведём простой синтетический тест, в нём максимально приблизим настройки баз данных. Скрипт на Go наполняет хранилище случайными ключами со случайными значениями.
```
MacBook Pro 2,9 GHz Quad-Core Intel Core i7
Redis version=6.0.9, bits=64
Tarantool 2.6.2
```
**Redis**
```
redis_test.go
package main
import (
"context"
"fmt"
"log"
"math/rand"
"testing"
"github.com/go-redis/redis"
)
func BenchmarkSetRandomRedisParallel(b *testing.B) {
client2 := redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379", Password: "", DB: 0})
if _, err := client2.Ping(context.Background()).Result(); err != nil {
log.Fatal(err)
}
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
key := fmt.Sprintf("bench-%d", rand.Int31())
_, err := client2.Set(context.Background(), key, rand.Int31(), 0).Result()
if err != nil {
b.Fatal(err)
}
}
})
}
```
**Tarantool**
```
tarantool>
box.cfg{listen='127.0.0.1:3301', wal_mode='none', memtx_memory=2*1024*1024*1024}
box.schema.user.grant('guest', 'super', nil, nil, {if_not_exists=true,})
box.schema.space.create('kv', {if_not_exists=true,})
box.space.kv:create_index('pkey', {type='TREE', parts={{field=1, type='str'}},
if_not_exists=true,})
```
```
tarantool_test.go
package main
import (
"fmt"
"math/rand"
"testing"
"github.com/tarantool/go-tarantool"
)
type Tuple struct {
_msgpack struct{} `msgpack:",asArray"`
Key string
Value int32
}
func BenchmarkSetRandomTntParallel(b *testing.B) {
opts := tarantool.Opts{
User: "guest",
}
pconn2, err := tarantool.Connect("127.0.0.1:3301", opts)
if err != nil {
b.Fatal(err)
}
b.RunParallel(func(pb *testing.PB) {
var tuple Tuple
for pb.Next() {
tuple.Key = fmt.Sprintf("bench-%d", rand.Int31())
tuple.Value = rand.Int31()
_, err := pconn2.Replace("kv", tuple)
if err != nil {
b.Fatal(err)
}
}
})
}
```
**Запуск** Чтобы полностью прогрузить базы данных, используем больше потоков.
```
go test -cpu 12 -test.bench . -test.benchtime 10s
goos: darwin
goarch: amd64
BenchmarkSetRandomRedisParallel-12 929368 15839 ns/op
BenchmarkSetRandomTntParallel-12 972978 12749 ns/op
```
**Результаты**. Среднее время запроса к Redis составило 15 микросекунд, к Tarantool — 12 микросекунд. Это даёт Redis 63 135 RPS, Tarantool — 78 437 RPS.
Тест нужен, чтобы показать уровень производительности БД в памяти, а не для замера, кто быстрее. Каждый из вас может измерить так, что быстрее окажется нужный вариант, я это тоже понимаю.
### Надёжность
Для надёжности хранения данных используют две основные техники:
* **Персистентность**. При перезагрузке БД загрузит свои данные с диска, не будет запросов в сторонние системы.
* **Репликация**. Если упал один узел, то есть копия на втором. Бывает асинхронная и синхронная.
И Redis, и Tarantool содержат эти функции. Технические подробности мы рассмотрим далее.
### Масштабируемость
Масштабирование может рассматриваться для двух задач:
* Зарезервировать дополнительные узлы, которые могут заменять друг друга в случае, если сосед вышел из строя.
* Данные не помещаются на один узел, и их необходимо распределить на несколько.
**Redis**
Узлы Redis можно соединить друг с другом асинхронной репликацией. Такие узлы будем называть репликационной группой, или replica set. Управлением такой репликационной группой занимается Redis Sentinel.
Redis Sentinel — это один или несколько объединенных в кластер специальных процессов, которые следят за узлами Redis. Они выполняют четыре основные задачи:
* Мониторинг узлов в группе: живой или мертвый.
* Уведомление администратора или какой-то системы, если что-то случилось в группе.
* Автоматическое переключение мастера.
* Провайдер конфигурации для внешних клиентов, чтобы они знали, к кому подключиться.
В случае, когда данные необходимо расшардировать на несколько узлов, Redis предлагает open source-версию Redis Cluster. Она позволяет построить кластер, состоящий из нескольких репликационных групп. Данные в кластере шардируются по 16 384 слотам. Диапазоны слотов распределяются между узлами Redis.
Узлы в кластере общаются по отдельному открытому порту, чтобы понимать состояния соседей. Приложение при работе с Redis Cluster должно использовать специальный коннектор.
**Tarantool**
Tarantool также содержит в себе оба механизма масштабирования: репликацию и шардирование. Основной инструмент управления масштабированием — Tarantool Cartridge. Он объединяет узлы в репликационные группы. В этой ситуации вы можете построить одну такую репликационную группу и использовать её аналогично Redis Sentinel. Tarantool Cartridge может управлять несколькими репликационными группами и шардировать данные между ними. Шардирование выполняется с помощью библиотеки vshard.
**Различия**
**Администрирование**
* Администрирование Redis Cluster — с помощью скриптов и команд.
* В Tarantool Cartridge администрирование — с помощью web-интерфейса или через API.
**Корзины шардирования**
* Количество корзин шардирования в Redis фиксированное, 16 тыс.
* Количество корзин шардирования Tarantool Cartridge (vshard) произвольное. Указывается один раз при создании кластера.
**Ребалансировка корзин (решардинг)**
* В Redis Cluster настройка и запуск вручную.
* В Tarantool Cartridge (vshard) — автоматически.
**Маршрутизация запросов**
* Маршрутизация запросов в Redis Cluster происходит на стороне клиентского приложения.
* В Tarantool Cartridge маршрутизация запросов происходит на узлах-роутерах кластера.
**Инфраструктура**
* Tarantool Cartridge также содержит:
+ механизм map/reduce запросов;
+ утилиту по упаковке приложения в пакеты rpm, dep и tar.gz;
+ Аnsible-роль для автоматического развёртывания приложения;
+ экспорт параметров мониторинга кластера.
### Валидация схемы данных
В Redis основная схема данных — ключ-значение. Но в значениях могут быть разные структуры. На стороне сервера нет механизма для задания правил. Мы не можем указать, в каком ключе какой тип данных должен использоваться и какая именно структура должна быть у значения. Валидацией схемы должен заниматься или коннектор, или клиентское приложение.
В Tarantool на стороне сервера можно использовать валидацию по схеме данных:
* с помощью встроенной валидации box.space.format, которая затрагивает только верхний уровень полей;
* с помощью установленного расширения avro-schema.
3. Технические особенности
--------------------------
### Какие типы данных можно хранить
В Redis ключом может быть только строка. В Redis можно хранить и манипулировать следующими типами данных:
* строки;
* списки строк;
* неупорядоченные множества строк;
* хешмапы или просто строковые пары ключ-значение;
* упорядоченные множества строк;
* Bitmap и HyperLogLog.
В Tarantool можно хранить и манипулировать следующими типами данных:
* Атомарными:
+ строки;
+ логический тип (истина, ложь);
+ целочисленный;
+ с плавающей запятой;
+ с десятичной плавающей запятой;
+ UUID.
* Комплексными:
+ массивы;
+ хешмапы.
Типы данных Redis лучше подходят для счётчиков событий, в том числе уникальных, для хранения небольших готовых витрин данных. А типы данных Tarantool лучше подходят для хранения объектов и/или документов, как в SQL и NoSQL СУБД.
### Вытеснение данных
Redis и Tarantool содержат в себе механизм ограничения занимаемой памяти. Когда клиент попытается добавить ещё данные, когда лимит уже был исчерпан, базы ответят ошибкой. И Redis, и Tarantool в этой ситуации продолжат выполнять запросы на чтение.
Перейдём к другому механизму, когда мы можем настроить алгоритм удаления «больше ненужных» данных. **Redis** содержит в себе несколько механизмов вытеснения:
* TTL — вытеснение объектов по завершении срока жизни;
* LRU — вытеснение **давно использованных** данных;
* RANDOM — вытеснение случайно попавшихся под руку объектов;
* LFU — вытеснение **редко используемых** данных.
Все механизмы могут быть настроены либо на весь объем данных, либо только на те объекты, которые помечены как вытесняемые.
В **Tarantool** для вытеснения данных можно использовать расширения expirationd или indexpiration, или создать собственную фоновую процедуру, которая будет проходить по индексу (например, с таймштампом) и удалять ненужные данные.
### Итерация по ключам
В **Redis** можно это сделать с помощью операторов:
* `SCAN`;
* итерация по ключам.
Операции возвращают страницы с результатами. Для получения каждой новой страницы, необходимо передать «идентификатор» предыдущей. Операции поддерживают фильтрацию по шаблону. Для этого используется параметр `MATCH`. Фильтрация происходит на момент выдачи страницы, поэтому некоторые страницы могут оказаться пустыми. Это не будет означать, что страниц больше не осталось.
В **Tarantool** доступна гибкая схема итерации по ключам. Можно итерироваться в прямом и обратном направлении. В процессе можно дополнительно фильтровать значения. Можно сместиться на определённое значение ключа, затем проходить по следующим ключам в сторону возрастания или убывания. Направление прохода на лету менять нельзя.
Например:
```
results = {}
for _, tuple in box.space.pairs('key', 'GE') do
if tuple['value'] > 10 then
table.insert(results, tuple)
end
end
return results
```
### Вторичные индексы
**Redis**
У Redis нет вторичных индексов. Есть некоторые трюки, чтобы их имитировать:
* В упорядоченных множествах можно использовать порядковый номер элемента как вторичный ключ.
* Использовать хешмапы, ключ которых является, в некотором смысле, индексом данных.
**Tarantool**
В Tarantool можно строить произвольное количество вторичных индексов для данных:
* Вторичные ключи могут состоять из нескольких полей.
* Для вторичных индексов можно использовать типы `HASH`, `TREE`, `RTREE`, `BITSET`.
* Вторичные индексы могут содержать уникальные и не уникальные ключи.
* У любых индексов можно использовать настройки локали, например, для регистронезависимых строковых значений.
* Вторичные индексы могут строиться по полям с массивом значений (иногда их называют мультииндексы).
**Вывод**
Вторичные ключи и удобные итераторы позволяют строить в Tarantool реляционные модели хранения данных. В Redis такую модель построить невозможно.
### Транзакции
Механизм транзакций позволяет выполнить несколько операций атомарно. И Redis, и Tarantool поддерживают транзакции. Пример транзакции в Redis:
```
> MULTI
OK
> INCR foo
QUEUED
> INCR bar
QUEUED
> EXEC
1) (integer) 1
2) (integer) 1
```
Пример транзакции в Tarantool:
```
do
box.begin()
box.space.kv:update('foo', {{'+', 'value', 1}})
box.space.kv:update('bar', {{'+', 'value', 1}})
box.commit()
end
```
### Персистентность
Персистентность данных обеспечивается двумя механизмами:
* периодическим сбросом in-memory данных на диск — snapshoting;
* последовательной упреждающей записью всех приходящих операций в файл — transaction journal.
И Redis, и Tarantool содержат оба механизма персистентности.
**Redis**
Redis периодически сбрасывает все данные из памяти на диск. Происходит это по-умолчанию каждые 60 секунд (настраивается). Redis использует механизм ОС fork для «копирования» текущих данных в памяти, затем информация сохраняется на диск. Если происходит аварийное завершение, то Redis восстановит состояние из последнего сохранения. Если последний снапшот был сделан давно, то данные, пришедшие после снапшота, будут утеряны.
Журнал операций используется для сохранения всей приходящей в базу информации. Каждая операция сохраняется в журнал на диске. Так, при запуске Redis восстанавливает своё состояние из снапшота и затем донакатывает оставшиеся транзакции из журнала.
* Снапшот в Redis называется RDB (redis database).
* Журнал операций в Redis называется AOF (append only file).
**Tarantool**
* Механизм персистентности взят из архитектур баз данных.
* Он является целостным — снапшоты и журналирование.
* Этот же механизм позволяет существовать надежной WAL-based репликации.
Tarantool периодически сохраняет текущие in-memory данные на диск и записывает каждую операцию в журнал.
* Снапшот в Tarantool называется snap (snapshot). Можно делать с произвольной частотой.
* Журнал транзакций в Tarantool называется WAL (write ahead log).
И в Redis, и в Tarantool каждый из механизмов может быть выключен. Для надёжного хранения данных оба механизма надо включить. Для максимального быстродействия можно отключить снапшотинг и журналирование, заплатив персистентностью. Слабоумие и отвага!
**Различия**
Для снапшотинга в Redis используется механизм ОС fork. Tarantool использует внутренний readview всех данных, это работает быстрее чем fork.
В Redis по умолчанию включён только снапшотинг. В Tarantool включён снапшотинг и журнал.
Redis хранит и использует только по одному файлу для снапшотов и журнала операций. Tarantool по-умолчанию хранит два файла снапшотов (можно настроить и больше) и консистентно дополняющее неограниченное количество журналов операций. При повреждении снапшот-файла Tarantool сможет загрузиться из предыдущего. Для Redis необходимо наладить механизм бекапов.
В Tarantool, в отличие от Redis, снапшоты и журналы образуют единый механизм отображения данных в файловой системе. Это значит, что в Tarantool и в файлах снапшотов и в журналах хранится полная метаинформация о транзакции, кто её сделал и когда. Она одного формата и взаимодополняющая.
**Troubleshooting**
Если повреждён файл журнала в Redis:
```
redis-check-aof --fix
```
Если повреждён файл журнала в Tarantool:
```
tarantool> box.cfg{force_recovery=true}
```
### Язык программирования для хранимых процедур
Хранимые процедуры — это код, выполняющийся рядом с данными. И Redis, и Tarantool предлагают Lua для создания хранимок. С точки зрения пользователя это очень простой язык. Он создавался для людей, для которых программирование будет инструментом решения задач в предметной области.
C точки зрения разработчика базы данных:
* Lua — это язык, который легко встраивается в существующее приложение.
* Он просто интегрируется с объектами и процессами приложения.
* Lua имеет динамическую типизацию и автоматическое управление памятью.
* Язык имеет сборщик мусора incremental Mark&Sweep.
**Различия**
**Реализация**
* В Redis используется ванильная реализация PUC-Rio.
* В Tarantool используется LuaJIT.
**Таймаут задач**
* В Redis можно задать таймаут, после которого выполнение хранимой процедуры прервётся.
* В Tarantool хранимые процедуры компилируются и выполняются быстрее, но в этом механизме нет возможности выставить таймаут. Для прерывания хранимой процедуры пользователь должен предусмотреть механизм проверки флага прерывания.
**Runtime**
* В Redis используется однозадачность: задачи выполняются по одной и целиком.
* В Tarantool используется кооперативная многозадачность. Задачи выполняются по одной, но при этом задача отдаёт управление на операциях ввода-вывода или явно с помощью yield.
**Вывод**
* В Redis Lua — это просто хранимые процедуры.
* В Tarantool — это кооперативный runtime, в котором можно взаимодействовать со внешними системами.
### Репликация
Репликация — это механизм копирования объектов с одного узла на другой. Бывает асинхронная и синхронная.
* Асинхронная репликация: при вставке объекта на один узел мы не дожидаемся, когда этот же объект будет отреплицирован на второй узел.
* Синхронная репликация: при вставке объекта мы дожидаемся, когда он будет сохранён на первом и втором узлах.
И Redis, и Tarantool поддерживают асинхронную репликацию. Только Tarantool умеет в синхронную репликацию.
На практике бывают ситуации, когда мы хотим дождаться репликации объекта. И в Redis, и в Tarantool есть способы для этого:
* В Redis это команда wait. Она принимает два параметра:
+ сколько реплик должны получить объект;
+ сколько ждать, пока это произойдёт.
* В Tarantool это можно сделать фрагментом кода:
псевдокод:
```
while not timeout do
if box.info.lsn <= (box.info.replication[dst].downstream.vclock[box.info.id] or 0) then
break
end
fiber.sleep(0.1)
end
```
**Синхронная репликация**
В Redis нет синхронной репликации. Начиная с Tarantool 2.6 синхронная репликация доступна [2].
### Коннекторы из других языков программирования
И Redis, и Tarantool поддерживают коннекторы для популярных языков программирования:
* Go;
* Python;
* NodeJS;
* Java.
Полные списки:
* <https://redis.io/clients>
* <https://tarantool.io/ru/download/connectors>
### Под какие задачи плохо подходят
И Redis, и Tarantool плохо подходят для решения OLAP-задач. Online analytical processing имеет дело с историческими или архивными данными. OLAP характеризуется относительно низким объёмом транзакций. Запросы часто очень сложны и включают агрегацию.
В обоих случаях данные хранятся построчно, и это снижает эффективность алгоритмов агрегации в сравнении с базами с колоночным хранением.
Redis и Tarantool — однопоточные базы данных, что не позволяет распараллелить аналитические запросы.
### Экосистема
**Redis**
Модули Redis представлены в трёх категориях:
* Enterprise;
* проверенные и сертифицированные для Enterprise и Open source;
* непроверенные.
Enterprise-модули:
* полнотекстовый поиск;
* хранение и поиск по bloom-фильтрам;
* хранение временных рядов.
Сертифицированные:
* хранение графов и запросы к ним;
* хранение JSON и запросы к нему;
* хранение и работа с моделями машинного обучения.
Все модули, отсортированные по количеству звёзд на Github:<https://redis.io/modules>
**Tarantool**
Модули представлены в двух категориях:
* Встроенные: <https://www.tarantool.io/en/doc/latest/reference/>
* Enterprise: <https://www.tarantool.io/en/enterprise_doc/rocksref/#closed-source-modules>
### Чем Redis лучше
* Проще.
* В интернете представлено больше информации, 20 тыс. вопросов на Stackoverflow (из них 7 тыс. без ответов).
* Ниже порог входа.
* Как следствие, проще найти людей, которые умеют работать с Redis.
### Чем Tarantool лучше
* Русскоязычная бесплатная поддержка в Telegram от разработчиков.
* Есть вторичные индексы.
* Есть итерация по индексу.
* Есть UI для администрирования кластера.
* Предлагает механику сервера приложений с кооперативной многозадачностью. Эта механика похожа на однопоточный Go.
4. Вывод
--------
Redis — это классный продвинутый кеш, но его нельзя брать как основное хранилище. Tarantool — это мультипарадигменная база данных, можно брать как основное хранилище. Tarantool поддерживает:
* Реляционную модель хранения с SQL.
* Распределённое NoSQL-хранилище.
* Создание продвинутых кешей.
* Создание брокера очередей.
У Redis ниже порог входа. У Tarantool выше потолок в production.
Сравнение одной таблицей:
| | Redis | Tarantool |
| --- | --- | --- |
| **Описание** | Продвинутый кэш в памяти. | Мультипарадигменная СУБД с сервером приложений. |
| **Модель данных** | Key-value | Key-value, документы, реляционная |
| **Сайт** | [redis.io](http://redis.io/) | [www.tarantool.io](http://www.tarantool.io/) |
| **Документация** | [redis.io/documentation](http://redis.io/documentation) | [www.tarantool.io/ru/doc/latest](http://www.tarantool.io/ru/doc/latest/) |
| **Разработчик** | Salvatore Sanfilippo, Redis Labs | [mail.ru](http://mail.ru/) Group |
| **Текущий релиз** | 6.2 | 2.6 |
| **Лицензия** | The 3-Clause BSD License | The 2-Clause BSD License |
| **Язык реализации** | C | C, C++ |
| **Поддерживаемые ОС** | BSD, Linux, MacOS, Win | BSD, Linux, MacOS |
| **Схема данных** | Key-value | Гибкая |
| **Вторичные индексы** | Нет | Есть |
| **Поддержка SQL** | Нет | Для одного инстанса, ANSI SQL |
| **Foreign keys** | Нет | Есть, с помощью SQL |
| **Триггеры** | Нет | Есть |
| **Транзакции** | Оптимистичные блокировки, атомарное выполнение. | ACID, read commited |
| **Масштабирование** | Шардинг по фиксированному диапазону. | Шардинг по настраиваемому количеству виртуальных бакетов. |
| **Многозадачность** | Да, сериализация сервером. | Да, кооперативная многозадачность. |
| **Персистентность** | Снапшоты и журналирование. | Снапшоты и журналирование. |
| **Концепция консистентности** | Eventual ConsistencyStrong eventual consistency with CRDTs | Immediate Consistency |
| **API** | Открытый протокол RESP [redis.io/topics/protocol](https://redis.io/topics/protocol) | Открытый бинарный протокол (на базе MsgPack) [www.tarantool.io/en/doc/latest/dev\_guide/internals/box\_protocol](https://www.tarantool.io/en/doc/latest/dev_guide/internals/box_protocol/) |
| **Язык скриптов** | Lua | Lua |
| **Поддерживаемые языки** | C, C#, C++, Clojure, Crystal, D, Dart, Elixir, Erlang, Fancy, Go, Haskell, Haxe, Java, JavaScript (Node.js), Lisp, Lua, MatLab, Objective-C, OCaml, Pascal, Perl, PHP, Prolog, Pure Data, Python, R, Rebol, Ruby, Rust, Scala, Scheme, Smalltalk, Swift, Tcl, Visual Basic | C, C#, C++, Erlang, Go, Java, JavaScript, Lua, Perl, PHP, Python, Rust |
5. Ссылки
---------
1. [Архитектура S3: три года эволюции Mail.ru Cloud Storage](https://habr.com/ru/company/mailru/blog/513356/)
2. [Синхронная репликация в Tarantool](https://habr.com/ru/company/mailru/blog/540446/)
3. Скачать Tarantool можно [на официальном сайте](https://www.tarantool.io/ru/download?utm_source=habr&utm_medium=articles&utm_campaign=2021), а получить помощь — [в Telegram-чате](https://t.me/tarantoolru?utm_source=habr&utm_medium=articles&utm_campaign=2021). | https://habr.com/ru/post/550062/ | null | ru | null |
# Рекомендации после установки Ubuntu 16.10
13 Октября компания Canonical представила Ubuntu 16.10. 16.10 является промежуточным релизом между LTS выпусками и по своей сути служит для отладки и тестирования новых возможностей.
### Список изменений
* В окне входа в систему появился тестовый сеанс Unity 8;
* Linux обновлен до версии 4.8;
* Большинство программ предоставляемых GNOME обновлены до версии 3.20 (некоторые 3.22);
* Использование systemd для пользовательских сеансов;
* Менеджер обновлений теперь отображает журнал изменений для репозиториев;
* Обновлены серверные приложения: OpenStack Newton, qemu 2.6.1, libvirt 2.1, Open vSwitch 2.6;
* KDE 5.7, MATE 1.16, Gnome 3.20.
В этой статье я хотел бы дать рекомендации, которые по моему мнению стоит сделать после установки Ubuntu.
### Обновление Системы
После первого запуска Ubuntu стоит сделать полное обновление системы. Самым простым способом для этого является выполнение одной команды в терминале (Ctrl+Alt+T):
```
sudo apt update && sudo apt upgrade
```
Так же можно воспользоваться приложением Обновление приложений, через меню Даш.
### Установка проприетарных драйверов
Если вы являетесь владельцом видекарты NVIDIA или AMD, вы можете установить проприетарный драйвер, который в теории увеличит производительность вашей системы. Для установки проприетарных драйверов выполните следующие дейсвтия:
1. Откройте Обновление приложений через меню Даш;
2. Выберите вкладку дополнительные драйвера;
3. Выберите драйвер для установки и введите пароль для подтверждения;
4. После установки потребуется перезагрузить систему.
### Установка Мультимедийных кодеков
Для воспроизвдения видео и аудио в Ubuntu потребуется установить пакет ubuntu-restricted-extras. Для его установки запустите терминал(Ctrl+Alt+T):
```
sudo apt install ubuntu-restricted-extras
```
Примечание: во время установки появится окно для подтверждения лицензионного соглашения, для подтверждения нажмите **Tab** и потом **Enter**.
### Настройка Интерфейса в Ubuntu
Для настройки интерфейса в Ubuntu (Как и в Gnome) используется консольная утилита gsettings, так же она имеет графический вариант Dconf Editor. Для установки Dconf Editor используйте следующую команду в терминале (Ctrl+Alt+T):
```
sudo apt install dconf-editor
```
### Минимизировать по клику
По умолчанию панель unity не позволяет сворачивать приложения по клику на панели. Для включения данной опции можно воспользоваться Dconf Editor или командой в терминале (Ctrl+Alt+T):
```
unityshell:/org/compiz/profiles/unity/plugins/unityshell/ launcher-minimize-window true
```
### Изменение положения панели Unity
По умолчанию панель расположена слева, но вы можете изменить ее положение с помощью команды в терминале (Ctrl+Alt+T):
```
gsettings set com.canonical.Unity.Launcher launcher-position Bottom
```
**Примечание:** вместа Bottom можно выбрать любое другое положение (Top, Left, Right, Bottom).
### Кастомизация интерфейса
Для кастомизации интерфейса (изменение GTK темы, иконок, шрифтов и т.п) можно воспользоваться программой Unity Tweak Tool. Для ее установки введите в терминале следующую команду:
```
sudo apt install unity-tweak-tool
```
Для выбора GTK темы и иконок, можно воспользоваться соответствующим разделом на сайте [OMG!Ubuntu](http://www.omgubuntu.co.uk/category/themes-2).
### Установка стороннего ПО
Ubuntu идет в комплекте с программами для ежедневного использования, но этих программ не хватает всем.
Для установки стороннего ПО можно воспользоваться Центром приложений Ubuntu. Вот список самых популярных бесплатных и свободных программ:
* **GIMP** — Графический редактор;
* **Corebird** — Клиент для твиттера;
* **Thunderbird** — E-Mail Клиент от Mozilla;
* **VLC** — Видео и Аудио проигрыватель;
* **Chromium** — Свободная реализация браузера Chrome от Google;
* **VirtualBox** — Программа для виртуализации ОС.
### Программа для очистки системы
С течением времени Ubuntu (как и любой другой дистрибутив Linux) «засоряется» ненужными для работы системы файлами и для их удаления вам может помочь программа BleachBit. Для установки воспользуйтесь данной командой в терминале (Ctrl+Alt+T):
```
sudo apt-get install bleachbit
```
Это были все рекомендации после установки Ubuntu 16.10 на вашь компьютер. Желаю вам удачи в настройке и использовании системы.
**P.S.** Статья предназначена исключительно для новичков, опытные пользователи не извлекут ничего нового из данной статьи. | https://habr.com/ru/post/356346/ | null | ru | null |
# Bun: новый рантайм для JavaScript
На днях произошёл релиз публичной беты. Давайте разберёмся, чем интересен [Bun](https://bun.sh).
Что такое рантайм?
> [**Среда выполнения/рантайм**](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B5%D0%B4%D0%B0_%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F)(runtime) в информатике — вычислительное окружение, необходимое для выполнения компьютерной программы и доступное во время выполнения компьютерной программы. В среде выполнения, как правило, невозможно изменение исходного текста программы, но может осуществляться доступ к переменным окружения операционной системы, таблицам объектов и модулей разделяемых библиотек.
>
>
Bun конкурирует с хорошо известными NodeJS и Deno.
Как позиционирует себя Bun:
> ... Bun это новый JavaScript рантайм с нативным сборщиком, транспайлером, исполнителем задач и встроенным npm клиентом.
>
>
Главное отличие от конкурентов - скорость. И вот почему:
* Bun использует движок JavaScriptCore(который под капотом у Safari), который немного [быстрее запускается и исполняет команды](https://twitter.com/jarredsumner/status/1499225725492076544).
* Bun написан на [Zig](https://ziglang.org/), низкоуровневом языке программирования, в котором реализовано ручное управление памятью.
* Автор Bun регулярно оптимизирует код.
Что умеет Bun
-------------
* транспилирует JSX/TS код
* поддерживает работу с npm
* имеет встроенное API для таких модулей, как fetch, WebSocket, ReadableStreams.
* Test Runner на подобие Jest, [только быстрее](https://twitter.com/jarredsumner/status/1542824445810642946)
* Http Server
* [Сборка приложения(бандлинг)](https://github.com/Jarred-Sumner/bun#bun-bun)
* [Остальное...](https://github.com/Jarred-Sumner/bun#table-of-contents)
Пробуем
-------
Установка:
`curl https://bun.sh/install | bash`
Давайте напишем простой *http server*. Создаём файл *http.js*:
```
// http.js
export default {
port: 3000,
fetch(request) {
return new Response("Welcome to Bun!");
},
};
```
Запускаем: `bun run http.js`
Проверяем, открыв в браузере <http://localhost:3000>
Итого
------
Так как это бета, то многие вещи не работают. Например, попробовав запустить mocha-тесты с моего NodeJS проекта выяснил, что:
* не поддерживаются декораторы
* не реализован встроенный модуль `node:child_process`
[Есть список с тем](https://github.com/Jarred-Sumner/bun#not-implemented-yet), что пока не работает.
Можете попробовать вызвать `bun install` в своём проект и сравнить скорость установки пакетов в сравнении с npm/yarn
---
В целом, я ждал релиза, так как следил за [автором в твиттере](https://twitter.com/jarredsumner) последний год и было видно, как он вкладывал очень много сил и времени в проект. Надеюсь, с полноценным релизом выйдет больше стабильного функционала и можно будет запускать на проде. А ещё автор контрибьютит в JavaScriptCore, что продвигает веб вперёд.
Думаю, что это будет хорошая альтернатива NodeJS/Deno/Babel/SWC/ESBuild/Vite/Webpack/Parcel/Mocha/Jest/TSC/(...?). Что думаете? | https://habr.com/ru/post/676102/ | null | ru | null |
# Stream API: универсальная промежуточная операция
Я разрабатываю бесплатную библиотеку [StreamEx](https://github.com/amaembo/streamex), которая расширяет стандартное Java 8 Stream API, добавляя туда новые операции, коллекторы и источники стримов. Обычно я не добавляю всё подряд, а всесторонне рассматриваю каждую потенциальную фичу. Например, при добавлении новой промежуточной ([intermediate](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#StreamOps)) операции встают такие вопросы:
1. Будет ли она действительно промежуточной, то есть не будет трогать источник до выполнения терминальной операции?
2. Будет ли она ленивой и вытаскивать из источника не больше данных, чем требуется?
3. Сработает ли она на бесконечном стриме? Требует ли она ограниченный объём памяти?
4. Будет ли она хорошо параллелиться?
Минусик по любому из этих пунктов заставляет серьёзно задуматься, добавлять ли такую операцию. Минусик по первому — это сразу нет. Например, у конкурентов в jOOλ есть операция [shuffle()](http://www.jooq.org/products/jOO%CE%BB/javadoc/0.9.7/org/jooq/lambda/Seq.html#shuffle--), которая выглядит как промежуточная, но на самом деле прямо сразу потребляет весь стрим в список, перемешивает его и создаёт новый стрим. Я такое не уважаю.
Минусики по остальными пунктам не означают сразу нет, потому что есть и стандартные операции, которые их нарушают. Второй пункт нарушает `flatMap()`, третий — `sorted()`, четвёртый — всякие `limit()` и `takeWhile()` (в JDK-9). Но всё-таки я стараюсь этого избегать. Однако на днях я открыл для себя операцию, которая плохо параллелится и в зависимости от использования может не сработать на бесконечном стриме, но всё же слишком хороша. Через неё удаётся буквально в несколько строчек выразить как практически любую существующую промежуточную операцию, так и кучу несуществующих. Я назвал операцию [headTail()](http://amaembo.github.io/streamex/javadoc/one/util/streamex/StreamEx.html#headTail-java.util.function.BiFunction-java.util.function.Supplier-).
Метод операции принимает два параметра-функции (везде ниже опускаю [PECS](http://habrahabr.ru/post/207360/) для краткости):
```
StreamEx headTail(BiFunction, Stream> mapper, Supplier> supplier)
```
Первая функция принимает два аргумента: первый элемент исходного стрима и стрим, содержащий все остальные элементы. Функция может сделать с этим всё что угодно и вернуть новый стрим, который и будет передан нижеследующим операциям. Второй аргумент — функция, не принимающая аргументов, которая возвращает стрим того же типа, что и первая функция. Она вызывается в случае, если исходный стрим оказался пустым. По факту вызывается только одна из функций и только один раз в процессе выполнения терминальной операции всего стрима.
Часто вторая функция должна возвращать просто пустой стрим (если исходный стрим пуст, то и результат пуст), поэтому её можно опускать:
```
StreamEx headTail(BiFunction, Stream> mapper)
```
Давайте посмотрим, что с этим можно сделать. Простой вариант использования может выглядеть так:
```
StreamEx.of("name", "John", "Mary", "Lucy")
.headTail((head, tail) -> tail.map(str -> head+": "+str))
.forEach(System.out::println);
```
Вывод:
```
name: John
name: Mary
name: Lucy
```
Здесь мы просто откусили первый элемент стрима и использовали его для конкатенации с последующими элементами. Так можно парсить текстовый файл, у которого в первой строке заголовки. Но это довольно скучно. Играясь с этим методом я обнаружил, что он гораздо мощнее. Давайте попробуем выразить через него основные промежуточные операции из JDK.
#### Stream.map
Операция map применяет заданную функцию ко всем элементам исходного стрима. Вот так она будет выглядеть через headTail():
```
public static StreamEx map(StreamEx input, Function mapper) {
return input.headTail((head, tail) -> map(tail, mapper).prepend(mapper.apply(head)));
}
```
Здесь мы пользуемся ещё одной простой операцией [prepend](http://amaembo.github.io/streamex/javadoc/one/util/streamex/StreamEx.html#prepend-T...-), без которой бы ничего не вышло. Это вариация на тему конкатенации двух стримов (в стандартном API есть Stream.concat). Здесь мы вызываем сами себя для хвоста, а затем добавляем в начало стрима результат применения функции к головному элементу.
Это похоже на рекурсию, а все знают, что рекурсия жрёт стек. В функциональных языках программирования порой спасает [оптимизация хвостовой рекурсии](https://ru.wikipedia.org/wiki/%D0%A5%D0%B2%D0%BE%D1%81%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D1%8F), но в Java её нет и не предвидится. Однако в данном случае это не совсем рекурсия: мы не вызываем метод map внутри самого себя, а только создаём функцию, которая будет вызвана позже. Оказалось, что в данном случае можно проконтролировать глубину вызовов, если изменения каждого отдельного `headTail()` затрагивают только начало стрима, оставляя неизменный хвост. Я не очень творчески назвал эту фичу «оптимизацией хвостовых стримов» (tail stream optimization). Она совместима с промежуточными операциями `prepend` (добавить что-то в начало стрима), `mapFirst` (изменить первый элемент стрима, не трогая остальное) и самим `headTail`. В принципе её можно бы было распространить на стандартные skip и dropWhile (с JDK-9), но моя библиотека обещает, что стандартные операции полностью совместимы с оригинальным Stream API, а тут возникли бы тонкие отличия.
Так или иначе, приведённая выше операция map не кушает стек или память больше константного размера и вполне применима для стримов любой длины. Давайте посмотрим на другие операции.
#### Stream.limit
Ограничить стрим заданной длиной. Если ограничить одним элементом, то просто создаём стрим из головы, иначе вызываем себя для хвоста с уменьшенным ограничением (обработать n <= 0 — упражнение для читателя):
```
public static StreamEx limit(StreamEx input, int n) {
return input.headTail((head, tail) -> n > 1 ? limit(tail, n - 1).prepend(head) : Stream.of(head));
}
```
Вначале я написал немного по-другому (как и аргумент flatMap, аргумент headTail может вернуть null вместо пустого стрима):
```
public static StreamEx limit(StreamEx input, int n) {
return input.headTail((head, tail) -> n > 0 ? limit(tail, n - 1).prepend(head) : null);
}
```
Но у такой реализации есть недостаток: она считает из источника на один элемент больше, чем надо (при n = 0 аргумент head считывается, но не используется). Иногда это может быть критично. Например, такой код должен работать:
```
limit(StreamEx.of(new Random().ints(0, 1000).boxed().distinct()), 1000).forEach(System.out::println);
```
Бесконечный поток случайных чисел от 0 до 999, из которого мы выбираем уникальные. 1000 уникальных есть, а вот 1001 нету, поэтому если пытаться вытащить из источника 1001-е число, то всё зависнет.
#### Stream.skip
Выкинуть n первых элементов. Если n = 0, вернём просто хвост с приклеенной головой, иначе вызовем себя с уменьшенным аргументом:
```
static StreamEx skip(StreamEx input, int n) {
return input.headTail((head, tail) -> n > 0 ? skip(tail, n - 1) : tail.prepend(head));
}
```
#### Stream.flatMap
Отобразить каждый элемент на стрим и сделать из них общий стрим. В нашем случае реализация такая же, как у map:
```
public static StreamEx flatMap(StreamEx input, Function> mapper) {
return input.headTail((head, tail) -> flatMap(tail, mapper).prepend(mapper.apply(head)));
}
```
Здесь отличие только в том, что используется другой [prepend](http://amaembo.github.io/streamex/javadoc/one/util/streamex/StreamEx.html#prepend-java.util.stream.Stream-), который принимает стрим (собственно, первый prepend — это частный случай этого).
#### Stream.peek
Выполнить дополнительное действие для каждого элемента стрима и вернуть стрим как есть. Выполняем действие и приклеиваем голову к хвосту:
```
public static StreamEx peek(StreamEx input, Consumer consumer) {
return input.headTail((head, tail) -> {
consumer.accept(head);
return peek(tail, consumer).prepend(head);
});
}
```
#### Stream.filter
Оставить элементы удовлетворяющие предикату. Приклеиваем голову, только если предикат выполняется:
```
public static StreamEx filter(StreamEx input, Predicate predicate) {
return input. headTail((head, tail) -> predicate.test(head)
? filter(tail, predicate).prepend(head)
: filter(tail, predicate));
}
```
#### Stream.distinct
Оставить уникальные элементы. Тут уже явно потребуется дополнительная память. Наивная реализация будет использовать filter (можно стандартный или объявленный выше):
```
public static StreamEx distinct(StreamEx input) {
return input.headTail((head, tail) -> distinct(tail.filter(n -> !Objects.equals(head, n))).prepend(head));
}
```
Но такой код всё же жрёт стек, оптимизации хвостовых стримов нет. Кроме того, каждый элемент проверяется цепочкой фильтров линейно, а хотелось бы оптимизировать. Для этого будем держать в параметрах HashSet:
```
private static StreamEx distinct(StreamEx input, Set observed) {
return input.headTail((head, tail) -> observed.add(head)
? distinct(tail, observed).prepend(head)
: distinct(tail, observed));
}
```
Не забываем, что `Set.add` возвращает `false`, если элемент уже был в множестве. В этом случае голову не приклеиваем. Такая реализация стек уже не кушает и по памяти не уступает стандартной. Тут стоит добавить метод для запуска (с рекурсивными функциями часто бывает, что нужен отдельный публичный метод для запуска):
```
public static StreamEx distinct(StreamEx input) {
return distinct(input, new HashSet<>());
}
```
#### Stream.sorted
Отсортировать стрим. Операция особенная: здесь нельзя ничего выдать в результат, пока источник не прочитан полностью. Придётся всё буферизовать (например, в `ArrayList`) и здесь нам впервые пригодится второй аргумент `headTail`:
```
public static StreamEx sorted(StreamEx input) {
return sorted(input, new ArrayList<>());
}
private static StreamEx sorted(StreamEx input, List buf) {
return input.headTail((head, tail) -> {
buf.add(head);
return sorted(tail, buf);
}, () -> {
buf.sort(null);
return buf.stream();
});
}
```
Когда весь исходный стрим кончился, мы сортируем буфер и возвращаем с него поток. Замечу, что такой `sorted` работает похоже на стандартный и он всё же лучше, чем приведённый выше `shuffle`. К примеру, если вы конкатенируете два сортированных стрима, второй не будет сортироваться, пока вы полностью не прочитаете первый. Кстати, заменив `buf.sort(null)` на `Collections.shuffle(buf)` вы и `shuffle` можете сделать более-менее нормально. А с `Collections.reverse(buf)` можно перевернуть стрим.
JDK-9 пока добавляет две новых промежуточных операции. Реализуем и их:
#### Stream.takeWhile
Обрезать стрим как только предикат вернёт false. Похоже на limit:
```
public static StreamEx takeWhile(StreamEx input, Predicate predicate) {
return input.headTail((head, tail) -> predicate.test(head)
? takeWhile(tail, predicate).prepend(head) : null);
}
```
#### Stream.dropWhile
Выкидывать элементы из стрима, пока предикат не вернёт `false`. Похоже на `skip`:
```
public static StreamEx dropWhile(StreamEx input, Predicate predicate) {
return input.headTail((head, tail) -> predicate.test(head) ? dropWhile(tail, predicate) : tail.prepend(head));
}
```
Ну изобретать велосипед скучно. Давайте попробуем реализовать новые операции, которых нет в Stream API.
#### mirror
Добавим в конец стрима его содержимое в обратном порядке (чтобы стрим из 1, 2, 3 превратился в 1, 2, 3, 3, 2, 1). Можно сделать просто, но без хвостовой оптимизации:
```
public static StreamEx mirror(StreamEx input) {
return input.headTail((head, tail) -> mirror(tail).append(head).prepend(head));
}
```
С хвостовой же потребуется буфер:
```
public static StreamEx mirror(StreamEx input) {
return mirror(input, new ArrayDeque<>());
}
private static StreamEx mirror(StreamEx input, Deque buf) {
return input.headTail((head, tail) -> {
buf.addFirst(head);
return mirror(tail, buf).prepend(head);
}, buf::stream);
}
```
Обе реализации не берут больше, чем надо: `mirror(StreamEx.of(1,2,3,4,5)).limit(3)` не дойдёт до точки отражения и вычитает только три элемента из источника.
#### scanLeft
Последовательно модифицируем стрим, выполняя заданную операцию. Например, `scanLeft(StreamEx.of(1,2,3,4,5), Integer::sum)` должен последовательно суммировать элементы и создать стрим `1, 3, 6, 10, 15`.
```
public static StreamEx scanLeft(StreamEx input, BinaryOperator operator) {
return input.headTail((head, tail) ->
scanLeft(tail.mapFirst(cur -> operator.apply(head, cur)), operator).prepend(head));
}
```
Здесь мы воспользовались методом [mapFirst](http://amaembo.github.io/streamex/javadoc/one/util/streamex/StreamEx.html#mapFirst-java.util.function.Function-), который уже есть в StreamEx. Но если б и не было, мы б его легко написали даже без всякой рекурсии:
```
public static StreamEx mapFirst(StreamEx input, UnaryOperator operator) {
return input.headTail((head, tail) -> tail.prepend(operator.apply(head)));
}
```
В любом случае хвосты оптимизируются, как с нашим mapFirst, так и с имеющимся.
#### takeWhileClosed
Название, возможно, не очень удачное. Иногда хочется модифицировать `takeWhile`, чтобы в поток попадали не только элементы, удовлетворяющие предикату, но и первый элемент, его нарушающий. Через существующие операции и через обычный `takeWhile` это нормально не выразить. А через `headTail` — легко:
```
public static StreamEx takeWhileClosed(StreamEx input, Predicate predicate) {
return input.headTail((head, tail) -> predicate.test(head)
? takeWhileClosed(tail, predicate).prepend(head)
: Stream.of(head));
}
```
#### every
Брать элементы из стрима с заданным интервалом (например, каждый десятый), начиная с первого. Здесь удобно скомбинировать с операцией `skip`, но стандартный `skip` не оптимизирует хвосты, поэтому воспользуемся нашим переопределённым `skip`:
```
public static StreamEx every(StreamEx input, int n) {
return input.headTail((head, tail) -> every(skip(tail, n - 1), n).prepend(head));
}
```
#### couples
Разбить стрим на непересекающиеся пары элементов, применив к ним заданную функцию (если элементов нечётное количество, последний выкинуть). Здесь удобно вызвать `headTail` дважды:
```
public static StreamEx couples(StreamEx input, BiFunction mapper) {
return input.headTail((left, tail1) ->
tail1.headTail((right, tail2) ->
couples(tail2, mapper).prepend(mapper.apply(left, right))));
}
```
#### pairMap
А если мы хотим с пересекающимися парами то же самое? Легко, надо только вернуть правый элемент в стрим при рекурсивном вызове:
```
public static StreamEx pairMap(StreamEx input, BiFunction mapper) {
return input.headTail((left, tail1) ->
tail1.headTail((right, tail2) ->
pairMap(tail2.prepend(right), mapper).prepend(mapper.apply(left, right))));
}
```
Такая операция уже есть в StreamEx, и я про неё [писал](https://habrahabr.ru/post/256905/). Она, конечно, нормально распараллеливается в отличие от реализации через `headTail()`.
#### batches
Ладно, с парами понятно. А если мы хотим разбить стрим на кусочки фиксированный длины (в виде списков) и не потерять нецелый кусочек в конце? Например, `batches(StreamEx(1,2,3,4,5,6,7), 3)` должно сделать поток из списков `[1,2,3], [4,5,6], [7]`. Тут поможет аргумент, содержащий промежуточный буфер:
```
public static StreamEx> batches(StreamEx input, int size) {
return batches(input, size, Collections.emptyList());
}
private static StreamEx> batches(StreamEx input, int size, List cur) {
return input.headTail((head, tail) -> cur.size() >= size
? batches(tail, size, Collections.singletonList(head)).prepend(cur) // старый буфер приклеиваем в голову и начинаем новый
: batches(tail, size, StreamEx.of(cur).append(head).toList()), // добавляем к старому буферу
() -> Stream.of(cur));
}
```
Когда источник исчерпан мы отдаём в результат последний накопленный буфер с помощью `() -> Stream.of(cur)`, чтобы не потерять хвост. Здесь для красоты реализации я каждый раз создаю новый список через `StreamEx.of(cur).append(head).toList()`, а не меняю существующий. Но несложно и изменяемые списки вставить, если важна производительность.
#### withIndices
Потребовалось узнать индексы элементов в стриме? Можно и это. Чтобы не заводить специальный тип вроде пары индекс-элемент, примем абстрактную функцию типа `BiFunction`, которая может с индексом и элементом сделать всё, что хочет:
```
public static StreamEx withIndices(StreamEx input, BiFunction mapper) {
return withIndices(input, 0, mapper);
}
private static StreamEx withIndices(StreamEx input, int idx, BiFunction mapper) {
return input.headTail((head, tail) -> withIndices(tail, idx + 1, mapper).prepend(mapper.apply(idx, head)));
}
```
#### dominators
Более экзотическая задача: будем выкидывать элементы, следующие после данного, над которыми данный «доминирует». Доминирование определяет предикат от двух элементов. Например, `dominators(numbers, (a, b) -> a >= b)` оставит из исходных чисел возрастающий поднабор. Реализация похожа на every, только вместо skip используется наш dropWhile:
```
public static StreamEx dominators(StreamEx input, BiPredicate isDominator) {
return input.headTail((head, tail) -> dominators(dropWhile(tail, e -> isDominator.test(head, e)), isDominator)
.prepend(head));
}
```
#### appendReduction
Добавить в конец стрима ещё один элемент — результат его редукции с заданной операцией. Например, `appendReduction(numbers, 0, Integer::sum)` допишет в стрим чисел сумму его элементов.
```
public static StreamEx appendReduction(StreamEx input, T identity, BinaryOperator op) {
return input.headTail((head, tail) ->
appendReduction(tail, op.apply(identity, head), op).prepend(head),
() -> Stream.of(identity));
}
```
Как обычно, всё лениво и хвосты оптимизируются.
#### primes
Скорее учебная задача. Сделать решето Эратосфена: ленивый поток простых чисел, который выкидывает те, что делятся на уже виденные ранее:
```
public static StreamEx sieve(StreamEx input) {
return sieve(StreamEx.iterate(2, x -> x+1));
}
private static StreamEx sieve(StreamEx input) {
return input.headTail((head, tail) -> sieve(tail.filter(n -> n % head != 0)).prepend(head));
}
```
Здесь хвостовой оптимизации не получается, хотя аналогичная штука на функциональных языках тоже, естественно, не оптимизируется. Но выглядит просто. Со стандартными настройками JVM успевает выдать простые числа до 200 000 с лишним, пока не упадёт со StackOverflowError.
Можно придумать и другие полезные операции. Например, повторить содержимое стрима в цикле заданное количество раз. Или сдублировать стрим, отфильтровав его двумя разными фильтрами (при этом не хранить в памяти то, что не прошло второй фильтр). Можно сделать бегущее окно (по аналогии с batches, но внахлёст). По факту что бы я ни придумал, мне удавалось это реализовать с помощью headTail весьма коротко (мои тесты [здесь](https://github.com/amaembo/streamex/blob/760976f6291e9c69cee61f4363efcff8acecf188/src/test/java/one/util/streamex/StreamExHeadTailTest.java#L57)). Во всяком случае, для меня headTail точно короче и понятнее, чем писать `Iterator` или `Spliterator`. Как я понимаю, в мире функционального программирования подобные штуки — обычное дело. Приятно, что и на Java это возможно.
Программируйте с удовольствием! | https://habr.com/ru/post/262139/ | null | ru | null |
# STM32 + DHT11
Попал мне в руки датчик температуры и влажности DHT11. Измеряет влажность в пределах 20-90% и температуру от 0 до 50°С. Погрешность измерения влажности 5%, температуры 2°С. Время захвата 1 сек. Интерфейс связи single wire ([datashit](http://www.micro4you.com/files/sensor/DHT11.pdf)). Столь скромные параметры ограничивают область применения датчика только бытовыми даже комнатными условиями.
Я хотел сравнить показания [устройства на HCH1000+DS18B20](http://habrahabr.ru/post/153395/) с DHT11.
Ошибочно я заключил что DHT11 и DS18B20 уживутся на одной шине. Оказалось протоколы у них совсем разные. После неудачного опыта, наспех собрал устройство для установления истины.
Готовой библиотеки DHT11 для STM32 не нашел. Для Arduino [здесь](http://embedded-lab.com/blog/?p=4333). Протокол связи single wire не имеет ничего общего с 1-wire. Разница между 0 и 1 получается из разницы длительности импульса.
Сперва удерживаем порядка 20 мс низкий уровень шины, потом отпускаем ее, через 20 мс датчик зажимает ее в 0 сам и держит 80 мкс потом отпускает на 80 мкс (формирует сигнал присутствия) за ним следует 40 бит данных, с одинаковым стартом — зажатием шины на 50 мкс и битом. бит 0 где-то 28 мкс, бит 1 — 70 мкс. Ну и на прощание датчик зажимает и отпускает шину. 40 бит данных это 5 байт из которых первых два влажность, следующие 2 температура и байт четности. Байт четности равен сумме предыдущих байт. 1-й байт и 3-й байты передают значения, 2 и 4 я так понял зарезервированы под десятые доли.
Самый простой способ считать длительность импульсов и записывать их в массив. Потом этот массив трансформировать в массив байт.Так родилась библиотека dht11.c.
```
uint16_t read_cycle(uint16_t cur_tics, uint8_t neg_tic){
uint16_t cnt_tics;
if (cur_tics < MAX_TICS) cnt_tics = 0;
if (neg_tic) {
while (!GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_3)&&(cnt_tics=MAX\_TICS) return DHT11\_NO\_CONN;
//convert data
for(i=2;i<42;i++){
(\*buf) <<= 1;
if (dt[i]>20) (\*buf)++;
if (!((i-1)%8) && (i>2)) buf++;
}
//calculate checksum
buf -= 5;
check\_sum = 0;
for(i=0;i<4;i++){
check\_sum += \*buf;
buf++;
}
if (\*buf != check\_sum) return DHT11\_CS\_ERROR;
return DHT11\_OK;
}
```
Проект содержащий библиотеку dht11.c [здесь](https://github.com/tarasii/DTH11.git). | https://habr.com/ru/post/160017/ | null | ru | null |
# Фишки XAML-разработчика: встраиваемые конвертеры
Разберём интересный и нестандартный сценарий использования конвертеров — *Inline Converter*.
Наверно, некоторые разработчики сталкивались с той проблемой, что при использовании конвертеров в параметры конвертера не передаётся информации о представлении, его контексте данных либо самом визуальном элементе, к которому осуществлена привязка. С одной стороны это хорошо, получается некоторая защита и разделение логики, не слишком правильно в конвертере напрямую работать с контролом, с другой же стороны в редких случаях именно из-за такого ограничения приходится идти на различные ухищрения.
Старая добрая событийная модель по-прежнему не утратила своей актуальности даже несмотря на то, что получил развитие мощный и эффективный механизм привязки данных (*Data Binding*). Конечно, не стоит использовать события в ущерб прогрессивным средствам разработки, но иногда их применение получается удобным и естественным.
Почему бы не скомбинировать оба этих способа? К примеру, таким образом
**ICompositeConverter**
```
using System.Windows.Data;
namespace Aero.Converters.Patterns
{
public interface ICompositeConverter : IValueConverter
{
IValueConverter PostConverter { get; set; }
object PostConverterParameter { get; set; }
}
}
```
**IInlineConverter**
```
using System;
using System.Globalization;
using System.Windows.Data;
namespace Aero.Converters.Patterns
{
public class ConverterEventArgs : EventArgs
{
public object ConvertedValue { get; set; }
public object Value { get; private set; }
public Type TargetType { get; private set; }
public object Parameter { get; private set; }
public CultureInfo Culture { get; private set; }
public ConverterEventArgs(object value, Type targetType, object parameter, CultureInfo culture)
{
TargetType = targetType;
Parameter = parameter;
Culture = culture;
Value = value;
}
}
public interface IInlineConverter : IValueConverter
{
event EventHandler Converting;
event EventHandler ConvertingBack;
}
//public interface IInlineConverter : IValueConverter
//{
// event Func Converting;
// event Func ConvertingBack;
//}
}
```
**InlineConverter**
```
using System;
using System.Globalization;
using System.Windows.Data;
using Aero.Converters.Patterns;
namespace Aero.Converters
{
public class InlineConverter : IInlineConverter, ICompositeConverter
{
public IValueConverter PostConverter { get; set; }
public object PostConverterParameter { get; set; }
public event EventHandler Converting;
public event EventHandler ConvertingBack;
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var args = new ConverterEventArgs(value, targetType, parameter, culture);
var handler = Converting;
if (handler != null) handler(this, args);
return PostConverter == null
? args.ConvertedValue
: PostConverter.Convert(args.ConvertedValue, targetType, PostConverterParameter, culture);
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
var args = new ConverterEventArgs(value, targetType, parameter, culture);
var handler = ConvertingBack;
if (handler != null) handler(this, args);
return PostConverter == null
? args.ConvertedValue
: PostConverter.ConvertBack(args.ConvertedValue, targetType, PostConverterParameter, culture);
}
}
}
```
Что мы получаем? Экземпляр конвертера нам нужно встроить в ресурсы контрола или представления, а в бехаин коде (*Code Behind*) представления сделать нужные обработчики для событий *Converting* и *ConvertingBack*, после чего эти события станут вызываться во время срабатывания привязки, а в обработчиках через указатель *this* будет доступно как само представление c визуальным деревом, так и контекст данных! Неожиданно получилась большая свобода действий, к тому же всё осталось идеологически верно, ведь в сам конвертер не попало интерфейсной логики, а она осталась лишь в бехаин коде.
Вот простой пример использования этого подхода
```
```
```
private void InlineConverter_OnConverting(object sender, ConverterEventArgs e)
{
e.ConvertedValue =
string.Format("Title: {0} \nDataContext:\n{1} \nConverter Value: {2}",
Title,
DataContext,
e.Value);
}
```
Дополнительное использование паттерна *Composite Converter* [*ICompositeConverter* ] позволяет объединять различные конвертеры в цепочки, модифицируя логику, без необходимости создания новых классов.
Увидеть в действии *Inline Converter* и некоторые другие можно в демонстрационном проекте *HelloAero* библиотеки *[Aero Framework](http://makeloft.by/ru/tools)* [[резервная ссылка](http://1drv.ms/1JsaRgl)].
Благодарю за внимание!
P.S. [Предыдущая статья о динамическом Grid](http://habrahabr.ru/post/276077)
*Update*
**Применение**
Необходимость в представленном методе на практике возникает нечасто, однако в то же время он может крайне облегчить жизнь в «неудобных» ситуациях. К примеру, таким образом можно заместить *MultiBinding* при портировании кода с *WPF* на *Windows Phone*, поскольку на мобильной платформе множественная привязка не поддерживается. Просто помните о встраиваемых конвертерах и в нужный момент вы найдёте для них применение. | https://habr.com/ru/post/276185/ | null | ru | null |
# Кортежи (tuple) в C#
Кортежи появились в C# начиная с версии 7.0 с целью обеспечения работы с наборами значений. Основное предназначение кортежей - обобщение нескольких элементов в структуру с упрощенным синтаксисом. Для использования кортежей необходим тип System.ValueTuple. Для использования кортежей в более ранних версиях .NET Framework в проект необходимо добавить NuGet пакет SystemValueTuple.
Основные свойства кортежей:
* кортежи определяются с неограниченным количеством элементов.
* Кортежи являются типом значений.
* Кортежи поддерживают операторы = и !=
* Значения кортежей являются общедоступными полями.
```
var tuple1 = (10, 23.4); //Определен кортеж tuple1 с двумя значениями 10 и 23.4
```
Обращение к значениям кортежа происходит через поля с названиями типа Item[номер], где номер - порядковый номер значения в кортеже. Рассмотрим на примере программы:
```
static void Main(string[] args)
{
int tuple1 = (11, 33); //Определение кортежа с целочисленными значениями
Console.WriteLine(tuple1.Item1); //Вывод на консоль 11
tuple1.Item2 *= 2; //Умножение второго значения на 2
}
```
Возможно определение типа для каждого из значений. Для этого перед именем кортежа в скобках указываются типы для каждого значения.
```
(string, int) tuple = ("Coin", 25);
```
Для каждого значения кортежа предусмотрена возможность индивидуального именования. Заданное имя элемента называется именем кандидата. Оно является дубликатором другого явного или неявного имени поля кортежа.
```
var tuple1 = (purchase:5, sale:10);
Console.WriteLine(tuple1.purchase);
```
Для определения кортежей можно применять переменные, с которыми в дальнейшем можно производить операции.
```
var (purchase, sale) = (5, 10);
Console.WriteLine(Purchase);
```
#### Применение кортежей
Кортежи могут передаваться в метод в качестве параметров и служить возвращаемым результатом. В частности, очень удобно возвращать кортеж в качестве результата в том случае, если метод возвращает только одно значение.
```
static void Main(string[] args)
{
var tuple1 = Method(); //Присваиваем кортежу tuple1 возвращаемое значение
Console.WriteLine(tuple1.Item1);
Console.WriteLine(tuple1.Item2);
}
private static (int, int) Method() //Метод, возвращающий кортеж
{
var res = (5, 10);
return res;
}
```
В следующем примере кортеж передается в метод в качестве параметра.
```
static void Main(string[] args)
{
var (purchase, sale) = Method ((5, 10), 3);
Console.WriteLine($"Purchase: {purchase} Sale: {sale}");
}
private static (int purchase, int sale) Method((int p, int s)tuple, int n)
{
var res = (purchase: tuple.p, sale: tuple.s + n);
return result;
}
```
#### Присваивание кортежей
В кортежах предусмотрена возможность присваивания. Для этого оба кортежа должны иметь одинаковое количество элементов, типы соответствующих значений должны совпадать или иметь возможность неявного приведения друг к другу. Значения присваиваются в порядке их расположения. При присвоении имена полей не учитываются.
```
(int, int) tuple1 = (22, 12);
(double A, double B) tuple2 = (2.15, 3,02);
tuple2 = tuple1;
```
#### Деконструкция кортежей
Деконструкцией кортежей называется операция присваивания экземпляра кортежа в отдельные переменные.
```
var tuple = ("Alex", 36);
(string name, int age) = tuple;
//или
string name;
int age;
(name, age) = tuple;
```
#### Проверка кортежей на равенство
```
var tuple1 = (23, 36);
var tuple2 = (17, 31);
Console.WriteLine(tuple1 == tuple2);
Console.WriteLine(tuple1 != tuple2);
```
Имена полей кортежей при сравнении не учитываются.
Условия возможности сравнения кортежей:
* Оба кортежа содержат одинаковое количество элементов.
* Элементы должны соответствовать возможности сравнения.
#### Кортежи в качестве параметров вывода
При выполнении рефакторинга метода, имеющего параметры out они могут иметь тип кортежа.
```
var limitsLookup = new Dictionary()
{
[2] = (4, 10),
[4] = (10, 20),
[6] = (0, 23)
};
if (limitsLookup.TryGetValue(4, out (int Min, int Max) limits))
{
Console.WriteLine($"Found limits: min is {limits.Min}, max is {limits.Max}");
}
```
#### Различия между типами кортежей System.ValueTuple и SystemTuple
Основные различия заключаются в следующем:
* Типы ValueTuple являются типами значений - типы Tuple - ссылочные типы.
* Типы ValueTuple являются изменяемыми типами - типы Tuple - неизменяемые.
* Значениями типов ValueTuple являются поля. Значениями типов Tuple являются свойства.
Список использованных источников* <https://metanit.com/sharp/tutorial/2.19.php>
* <https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/builtin-types/value-tuples>
* <https://coderoad.ru/11146966/c-%D0%9A%D0%BE%D1%80%D1%82%D0%B5%D0%B6-%D0%BA%D0%B0%D0%BA%D0%BE%D0%B2%D0%BE-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5-%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D1%80%D1%82%D0%B5%D0%B6%D0%B0> | https://habr.com/ru/post/573088/ | null | ru | null |
# Port Knocking для Windows
Мне довольно часто приходится настраивать "одинокие" терминальные сервера(и не только терминальные) в "Облаках", с "легким, быстрым" доступом к нему по RDP.
Все объяснения для пользователей\заказчиков, что такие сервера должны быть доступны только с доверенных IP или через VPN или с 2FA, воспринимаются "в штыки" и тогда приходится рисковать...
Конечно сервер защищается от Bruteforce(а), используются парольная политика, нестандартный порт, но все равно сервер постоянно под угрозой, в месяц можно увидеть по 15000 попыток подобрать пароль.
Такое обстоятельство дел заставило меня подумать о простом и действенном способе защиты сервера и в то же время этот способ не должен усложнить пользователям подключение к серверу.
Первое что пришло в голову - Port Knocking, использую его на RouterOS, но беглое гугление показало что для Windows не существует подобного штатного функционала, поиск сторонних средств которые могли бы помочь организовать задуманное не дал результата, больше покопавшись нашел только странные и страшные поделки на Java не внушавшие доверия.
Тогда решил сделать свой PortKnocking для Windows. Написать его решил на PowerShell, чтоб не пришлось устанавливать на сервер дополнительно Java или Python.
Т.к. есть опыт c телеграм ботами(@SuperMon\_Bot), решил добавить и информирование о работе PortKnocking через телеграм.
Определился что вся задумка должна состоять из нескольких скриптов:
* Подготовка и настройка всего необходимого, создание правил фаервола, создание задач в планировщике, деактивация старых правил RDP.
* Главный скрипт который слушает порты и добавляет адреса в правила фаервола.
* Скрипт который обнуляет список адресов из правила фаервола.
* Позже коллега уговорил меня добавить скрипт который проверят корректность выбранных портов и возможность их использовать.
Решил что постучится на два разных порта от большего к меньшему, с небольшой разницей во времени будет достаточно.
Например, постучаться на порт 65000 и в течении 3-х секунд постучаться на порт 1025.
Все настройки решил вынести в отдельный файл XML, для удобства, чтоб не преходилось менять эти данные в нескольких разных скриптах.
0. settings.xml
Hidden text
```
XXXXXXX
YYYYY
zzzz
zzzz
63389
z.z.z.z
```
Пояснение XML:
Telegramtoken - вставляем токен телеграм бота. Как регистрировать ботов описывать не буду, подобной информации достаточно в интернете.
Telegramchatid - вставляем ID пользователя или чата, куда будут отправляться информация о работе приложения.
port1 - порт на котором будет ожидаться первый стук.
port2 - порт на котором будет ожидаться второй стук.
SafeIPs - доверенные адреса с которых должен остаться доступ даже без стука.
1. Далее пишу главный скрипт который будет слушать порты и добавлять постучавших в разрешённые IP:
Port-Knocking-2-main.ps1
Hidden text
```
#Вычитиваем данные из XML
[xml]$xmlConfig = Get-Content -Path ("C:\Install\Port-Knocking\settings.xml")
$Telegramtoken = $xmlConfig.config.system.Telegramtoken
$Telegramchatid = (($xmlConfig.config.system.Telegramchatid).Split(",")).Trim()
$port1 = $xmlConfig.config.system.port1
$port2 = $xmlConfig.config.system.port2
#Добавляем функцию отправки сообщений в телеграм
Function Send-Telegram {
Param([Parameter(Mandatory=$true)][String]$Message)
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
$Response = Invoke-RestMethod -Uri "https://api.telegram.org/bot$($Telegramtoken)/sendMessage?chat_id=$($Telegramchatid)&text=$($Message)"
}
#Основная часть срипта
#Вечный цикл
While ($True) {
$Listener1 = [System.Net.Sockets.TcpListener][int]$port1; #Слушаем первый порт
$Listener1.Start();
While($true){
$client1 = $Listener1.AcceptTcpClient();
$IP1 = $client1.client.RemoteEndPoint.Address.IPAddressToString
$Client1.Close();
break
}
#Слушаем второй порт 4 секунды
$Listener1.Stop()
$IP2 = Start-Job -Name port2 {
[xml]$xmlConfig = Get-Content -Path ("C:\Install\Port-Knocking\settings.xml")
$port2 = $xmlConfig.config.system.port2
$Listener2 = [System.Net.Sockets.TcpListener][int]$port2;
$Listener2.Start();
$Client2 = $Listener2.AcceptTcpClient();
$IP2 = $client2.client.RemoteEndPoint.Address.IPAddressToString
$Client2.Close();
$Listener2.Stop()
return $IP2
} | Wait-Job -Timeout 4 | Receive-Job
Stop-Job -Name port2
Remove-Job -Name port2
#Сравниваем IP
if ($IP1 -eq $IP2){
$CurrentIPs = (Get-NetFirewallRule -DisplayName "!RDP-for-port-knocking" | Get-NetFirewallAddressFilter ).RemoteAddress
$CurrentIPs += $IP2
Set-NetFirewallRule -DisplayName "!RDP-for-port-knocking" -RemoteAddress $CurrentIPs
Send-Telegram -Message "$env:COMPUTERNAME added IP - $IP1" #Если IP совпали, добавляем в правило фаервола и отправляем сообщение в телегу
}
else {
Send-Telegram -Message "$env:COMPUTERNAME was scanned from $IP1" #Если не совпали, отправляем собщение что нас сканировали
}
# Обнуляем IP
$IP1 = $null
$IP2 = $null
}
```
2. Далее приступил к скрипту который в конце суток удаляет все добавленные IP, кроме тех что в списке SafeIPs
Port-Knocking-3-ZeroTime.ps1
Hidden text
```
[xml]$xmlConfig = Get-Content -Path ("C:\Install\Port-Knocking\settings.xml")
$Telegramtoken = $xmlConfig.config.system.Telegramtoken
$Telegramchatid = (($xmlConfig.config.system.Telegramchatid).Split(",")).Trim()
$SafeIPs = (($xmlConfig.config.system.SafeIPs).Split(",")).Trim()
Set-NetFirewallRule -DisplayName "!RDP-for-port-knocking" -RemoteAddress $SafeIPs
Function Send-Telegram {
Param([Parameter(Mandatory=$true)][String]$Message)
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
$Response = Invoke-RestMethod -Uri "https://api.telegram.org/bot$($Telegramtoken)/sendMessage?chat_id=$($Telegramchatid)&text=$($Message)"
}
Send-Telegram -Message "$env:COMPUTERNAME cleared IPs"
```
3. Далее приступил к скрипту который по сути "подготавливает почву" для работы главного скрипта:
Port-Knocking-0-Install.ps1
Hidden text
```
#Start-Transcript -Path C:\Install\Port-Knocking\log01.txt -Append -Force
[xml]$xmlConfig = Get-Content -Path ("C:\Install\Port-Knocking\settings.xml")
$port1 = $xmlConfig.config.system.port1
$port2 = $xmlConfig.config.system.port2
$RDPport = $xmlConfig.config.system.RDPport
$PortsListener = $port1, $port2
$SafeIPs = (($xmlConfig.config.system.SafeIPs).Split(", ")).Trim()
#Создаем павило для RDP для подстраховки, чтоб не потерять управление сервером.
New-NetFirewallRule -DisplayName '!RDP-for-SafeIPs' -Direction Inbound -LocalPort $RDPport -Protocol TCP -Action Allow –RemoteAddress $SafeIPs -Enabled True -Verbose
#Создаем правило RDP для Port Knocking
New-NetFirewallRule -DisplayName '!RDP-for-port-knocking' -Direction Inbound -LocalPort $RDPport -Protocol TCP -Action Allow –RemoteAddress $SafeIPs -Enabled True -Verbose
#Создаем правило для портов на которые будем ожидать стук
New-NetFirewallRule -DisplayName '!For-port-knocking-Listener' -Direction Inbound -LocalPort $PortsListener -Protocol TCP -Action Allow -Enabled True -Verbose
#Отключаем “старое” правило для RDP
Get-NetFirewallPortFilter | Where-Object LocalPort -eq $RDPport | Get-NetFirewallRule | Where-Object {($_.DisplayName -ne '!RDP-for-port-knocking') -and (($_.DisplayName -ne '!RDP-for-SafeIPs'))} | Disable-NetFirewallRule
#Создаем задачу в планировщике для запуска основного скрипта
Register-ScheduledTask -TaskName 'Port-Knocking-2-main-task' -Xml (Get-Content 'C:\Install\Port-Knocking\Tasks\Port-Knocking-2-main-task.xml' | Out-String) -Force
#Создаем задачу в планировщике для запуска “обнуления” адресов
Register-ScheduledTask -TaskName 'Port-Knocking-3-ZeroTime' -Xml (Get-Content 'C:\Install\Port-Knocking\Tasks\Port-Knocking-3-ZeroTime.xml' | Out-String) -Force
#Запускаем задачу прослушивания портов
Start-ScheduledTask -TaskName 'Port-Knocking-2-main-task'
```
Задачи в планировщике решил для упрощения создать с помощью экспорта из XML.
Сами задачи ниже:
Port-Knocking-2-main-task.xml
Hidden text
```
xml version="1.0" encoding="UTF-16"?
2022-10-13T16:40:50.3934022
Admin
\Port-Knocking-2-main-task
S-1-5-18
HighestAvailable
true
true
PT0S
IgnoreNew
20
PT5M
true
true
false
P1D
PT5M
PT2M
P1D
Powershell.exe
-ExecutionPolicy Bypass -File "C:\Install\Port-Knocking\Port-Knocking-2-main.ps1"
```
Создается задача Port-Knocking-2-main-task с такими параметрами:
Запуск - при старте системы
Запуск программы - Powershell.exe -ExecutionPolicy Bypass -File "C:\Install\Port-Knocking\Port-Knocking-2-main.ps1"
Немедленно запускать задачу если пропущен плановый запуск
При сбое выполнения перезапускать через 5 минут
Если задача уже выполняется - не запускать новый екземпляр.
Port-Knocking-3-ZeroTime.xml
Hidden text
```
xml version="1.0" encoding="UTF-16"?
2022-10-13T18:14:46.5186083
Admin
\Port-Knocking-3-ZeroTime
S-1-5-18
HighestAvailable
true
true
PT1H
IgnoreNew
true
false
2022-10-13T23:59:00
PT30M
1
Powershell.exe
-ExecutionPolicy Bypass -File "C:\Install\Port-Knocking\Port-Knocking-3-ZeroTime.ps1"
```
Создается задача Port-Knocking-2-main-task с такими параметрами:
Запуск - Ежедевно в 23:59
Запуск программы - Powershell.exe -ExecutionPolicy Bypass -File C:\Install\Port-Knocking\Port-Knocking-3-ZeroTime.ps1"
Останавливать задачу выполняемую дольше 1ч.
4. Позже, по просьбе коллеги как говорил выше написал скрипт проверки возможности использования выбранных портов. Хотя по моему мнению это лишнее, настоящий администратор знает что происходит на сервере или как это проверить вручную)))
Check-correct-settings.ps1
Hidden text
```
$ErrorActionPreference = 'SilentlyContinue'
[xml]$xmlConfig = Get-Content -Path ("C:\Install\Port-Knocking\settings.xml")
$port1 = $xmlConfig.config.system.port1
$port2 = $xmlConfig.config.system.port2
$RDPport = $xmlConfig.config.system.RDPport
$RDPport0 = (Get-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp' -name "PortNumber").PortNumber
$RDPportState = Get-NetTCPConnection -LocalPort $RDPport0 -State Listen
if (($RDPport -eq $RDPport0) -and ($RDPportState)){
Write-Host "RDP port - $RDPport0 and port is OK" -ForegroundColor Green
}
else{
Write-Host "RDP port is not $RDPport0 or port in not liten, check please..." -ForegroundColor Red
}
$port1State = Get-NetTCPConnection -LocalPort $port1 -State Listen
$port2State = Get-NetTCPConnection -LocalPort $port2 -State Listen
if (($port1State -eq $null) -and ($port2State -eq $null)){
Write-Host "This ports($port1, $port2) can be use for Port-Knocning" -ForegroundColor Green
}
else{
Write-Host "This ports($port1, $port2) can not be use for Port-Knocning" -ForegroundColor Red
}
```
Результат работы скрипта если RDP порт выбран неправильно.
5. Далее встал вопрос как пользователям стучаться. Для админа это совсем не вопрос есть telnet, Test-NetConnection, есть даже готовые клиенты.
Но для пользователей подготовил папку в которой лежит маленький exe(paping.exe) и CMD файл с таким содержимым:
paping.exe X.X.X.X -p zzz -c 2
sleep 1
paping.exe X.X.X.X -p zzz -c 2
6. Протестировав данную поделку в течении пары недель остался доволен, пользователи сильно не бурчали, попытки подобрать пароль к серверу свелись практически к нулю.
Как это работает на практике:
Администратор копирует папку, запускает от имени адмнистратора скрипт Port-Knocking-0-Install.ps1
Готово к использованию.
Пользователь при первом подключении в день запускает файл
Пользователь ждет 3 секунды
Пользователь подключается к серверу как обычно по RDP.
Больше в эти сутки запускать Knocker не нужно, только на следующие сутки.
Примеры сообщений которые получает администратор
При добавлении IP.
Если сервер был просканирован то получаем сообщение.
В 23:59 Администратор получает сообщение.
Естественно сообщения можно и не получать :-)
Все на усмотрение всемогущего Администртора :-)
Мне и моим коллегам данная поделка пригодилась, надесь будет полезно и другим.
[**Ссылка на Github**](https://github.com/goro22052/Port-Knocking-for-Windows) | https://habr.com/ru/post/697490/ | null | ru | null |
# Визуальные карты сетей кластеров K8s для оценки их производительности
[](https://habr.com/ru/company/ruvds/blog/712536/)
Создание производительных сервисов и систем — основа любого бизнеса. Ежедневно появляются кучи новых технологий, которые обещают дать возможности, позволяющие превзойти ваши бенчмарки производительности. Однако продакшен-среды — это хаотичные системы, мониторинг и поддержка которых требует большой доли ресурсов.
Хотя [Kubernetes](https://dzone.com/articles/how-kubernetes-changed-container-management) при выборе системы управления контейнерами является стандартом «де факто», многим организациям не удаётся её реализовать. Растущие организации в процессе увеличения масштабов своих сервисов ненамеренно вносят в систему усложнения. Критически важно понимать, как настраивать инфраструктуру и как кластеры могут работать и взаимодействовать между собой.
Основная часть инфраструктуры упорядочивается в виде сети систем, обменивающихся данными и разделяющих рабочие нагрузки. Очень удобна возможность визуального наблюдения за соединением систем и выявления влияющих на них факторов. Создание карты сети при помощи эффективного инструмента визуализации и контроля является обязательной задачей для мониторинга и поддержки сервисов.
Введение в визуальное картографирование сетей
---------------------------------------------
Создание карт сетей — это процесс выявления и каталогизации всех устройств и соединений в сети. Визуальная карта сети — это визуальное представление сети, отображающее устройства и связи между ними. Визуальные карты сетей обеспечивают понимание топологии сети и выявляют потенциальные проблемы или узкие места, что позволяет создавать планы модификации и расширения, способные существенно улучшить процесс устранения проблем, планирования, анализа и мониторинга.
Для картографирования сетей и генерации визуальных карт сетей можно использовать опенсорсные инструменты безопасности наподобие OpenVAS, Nmap и Nessus. Эти инструменты бесплатны, что делает их экономичным решением для организаций, стремящихся повысить безопасность сетей. Кроме того, многие опенсорсные инструменты безопасности имеют активную поддержку сообщества, позволяя пользователям делиться знаниями, советами и рекомендациями по реализации полного потенциала инструмента.
Преимущества использования визуальных карт сетей
------------------------------------------------
Визуальная карта сети — это эффективный инструмент для планирования и разработки новых сетей, расширения или модернизации имеющихся сетей и анализа сетевых проблем.
Правильная настройка визуальных карт сетей может существенно расширить возможности мониторинга, трекинга и устранения неполадок. Она предоставляет вам чёткую и полную картинку сети, позволяя выявлять потенциальные источники проблем и разрешать и их; также она помогает в мониторинге сетей в реальном времени и заранее уведомляет о любых изменениях или проблемах.
Знакомство с Caretta и Grafana
------------------------------
[Caretta](https://github.com/groundcover-com/caretta) — это опенсорсный инструмент визуализации и мониторинга сетей, позволяющий просматривать и мониторить сети в реальном времени.
[Grafana](https://grafana.com/) — это опенсорсная платформа визуализации и мониторинга данных, позволяющая создавать собственные дэшборды и алерты, а также исследовать и анализировать данные.
На основе Caretta и Grafana можно создать эффективное решение для понимания сети и управления ею.
### ▍ Как Caretta использует eBPF и Grafana
Предназначение Caretta заключается в том, чтобы помочь в понимании топологии и взаимосвязи между устройствами в распределённых средах. Она предлагает различные возможности, например, выявление устройств, мониторинг в реальном времени, алерты, уведомления и отчётность. Для сбора и публикации своих метрик она использует Victoria Metrics, а результаты её работы можно использовать в любом совместимом с Prometheus дэшборде.
Благодаря обеспечению допусков (toleration) Carreta позволяет принимать типичные аннотации узлов уровня управления. Она собирает информацию сети, например, сведения об устройствах и соединениях, при помощи функциональности ядра [eBPF](https://ebpf.io/) (extended Berkeley Packet Filter), а затем использует платформу Grafana для отображения информации на визуальной карте.
### ▍ Роль Grafana в визуализации карт сетей Caretta
[Grafana](https://dzone.com/articles/-grafana-the-open-observability-platform) спроектирована так, чтобы быть модульным и гибким инструментом, с лёгкостью интегрирующим и принимающим широкий диапазон источников данных и приложений.
Благодаря возможности настройки функций вы можете изменять способ отображения карты сети при помощи дэшборда Grafana. Кроме того, у вас есть широкий выбор из множества опций визуализации для отображения данных в понятном и полезном виде. Grafana критически важна и для демонстрации данных сетей, собранных Caretta, и для предоставления пользователям полной картины сети.
Использование Caretta и Grafana для создания визуальной карты сети
------------------------------------------------------------------
Чтобы использовать Caretta и Grafana в создании визуальной карты сети, их необходимо установить, внедрить и конфигурировать. Основной объект конфигурирования — это Caretta daemonset.
Для просмотра карты сети необходимо развернуть Caretta daemonset в выбранном кластере, который будет собирать метрики сети в базу данных, а также настроить источник данных Grafana так, чтобы указывал на базу данных Caretta.
### ▍ Обязательные требования для использования Caretta и Grafana
Caretta — современный инструмент, интегрированный с расширенными функциями. Он использует версию ядра [Linux](https://dzone.com/articles/a-little-linux-goes-a-long-way) от 4.16 и выше и [helm chart](https://helm.sh/docs/chart_template_guide/values_files/) для 64-битной системы.
Давайте разберёмся, как установить и сконфигурировать это сочетание инструментов.
### ▍ Установка и конфигурирование Caretta и Grafana
При наличии заранее сконфигурированный helm chart для установки Caretta достаточно всего нескольких вызовов.
Рекомендуется устанавливать Caretta в новое уникальное пространство имён.
```
helm repo add groundcover https://helm.groundcover.com/
helm repo update
helm install caretta --namespace caretta --create-namespace groundcover/caretta
```
То же самое относится и к установке Grafana.
```
helm install --name my-grafana --set "adminPassword=secret" \n
--namespace monitoring -f custom-values.yaml stable/grafana
```
Наш файл `custom-values.yaml` будет выглядеть примерно так:
```
## Grafana configuration
grafana.ini:
## server
server:
protocol: http
http_addr: 0.0.0.0
http_port: 3000
domain: grafana.local
## security
security:
admin_user: admin
admin_password: password
login_remember_days: 1
cookie_username: grafana_admin
cookie_remember_name: grafana_admin
secret_key: hidden
## database
database:
type: rds
host: mydb.us-west-2.rds.amazonaws.com
## session
session:
provider: memory
provider_config: ""
cookie_name: grafana_session
cookie_secure: true
session_life_time: 600
## Grafana data
persistence:
enabled: true
storageClass: "-"
accessModes:
- ReadWriteOnce
size: 1Gi
```
### ▍ Конфигурирование
Сконфигурировать Caretta можно при помощи значений helm. Значения в Helm — это позиции настройки chart. После установки chart можно изменить значения, перечисленные в файле `values.yaml`, являющемся частью пакета chart, и настроить конфигурации на основании своих требований.
Ниже представлен пример конфигурации с переписыванием стандартных значений:
```
pollIntervalSeconds: 15 # set metrics polling interval
tolerations: # set any desired tolerations
- key: node-role.kubernetes.io/control-plane
operator: Exists
effect: NoSchedule
config:
customSetting1: custom-value1
customSetting2: custom-value2
victoria-metrics-single:
server:
persistentVolume:
enabled: true # set to true to use persistent volume
ebpf:
enabled: true # set to true to enable eBPF
config:
someOption: ebpf_options
```
`pollIntervalSeconds` задаёт интервал опроса метрик. В нашем случае метрики будут запрашиваться каждые 15 секунд.
В разделе tolerations можно указать допуски для подов. В показанном выше примере поды могут работать только в узлах, имеющих метку `node-role.kubernetes.io/control-plane` и с эффектом `NoSchedule`.
Раздел config позволяет указать собственные опции конфигурации для приложения.
Раздел victoria-metrics-single позволяет сконфигурировать сервер Victoria-metrics-single. В примере мы включаем использование постоянного хранилища (persistent volume).
Раздел `eBPF` позволяет включить eBPF и настроить его опции.
### ▍ Создаём визуальную карту сети с помощью Caretta и Grafana
Caretta состоит из двух частей: Caretta Agent и Caretta Server. Каждый узел в кластере выполняет Caretta Agent Kubernetes DaemonSet, собирающий информацию о состоянии кластера.
Для просмотра данных в виде карты сети и генерации карты сети необходимо добавить в Grafana данные, собранные Caretta.
```
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: caretta-depoy-test
namespace: caretta-depoy-test
spec:
selector:
matchLabels:
app: caretta-depoy-test
template:
metadata:
labels:
app: caretta-depoy-test
spec:
containers:
- name: caretta-depoy-test
image: groundcover/caretta:latest
command: ["/caretta"]
args: ["-c", "/caretta/caretta.yaml"]
volumeMounts:
- name: config-volume
mountPath: /caretta
volumes:
- name: config-volume
configMap:
name: caretta-config
```
Данные из Caretta Agent получаются Caretta Server (который является [Kubernetes StatefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)), после чего он сохраняет их в базу данных.
```
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: caretta-depoy-test
labels:
app: caretta-depoy-test
spec:
serviceName: caretta-depoy-test
replicas: 1
selector:
matchLabels:
app: caretta-depoy-test
template:
metadata:
labels:
app: caretta-depoy-test
spec:
containers:
- name: caretta-depoy-test
image: groundcover/caretta:latest
env:
- name: DATABASE_URL
value: mydb.us-west-2.rds.amazonaws.com
ports:
- containerPort: 80
name: http
```
Чтобы сделать это, нам нужно создать собственный плагин источника данных в Grafana для подключения к данным Caretta, а затем разработать визуализации в Grafana для отображения этих данных.
```
[datasources]
[datasources.caretta]
name = caretta-deploy-test
type = rds
url = mydb.us-west-2.rds.amazonaws.com
access = proxy
isDefault = true
```
### ▍ Опции настройки для карты сети и как получить к ним доступ
Карту сети, созданную Caretta и Grafana, можно настраивать множеством разных способов. Мы можем изменять следующие параметры:
* **Опции отображения**: при помощи опций настройки отображения вы можете управлять структурой карты, толщиной и цветом соединений и устройств.
* **Опции данных**: при помощи опций данных можно выбирать, какая информация будет отображаться на карте, в том числе уведомления, метрики производительности, сведения об устройстве и подключении.
* **Опции алертов**: при помощи опций алертов можно получать уведомления о любых изменениях и проблемах в сети, например, о большом трафике, низкой производительности или трудностях со связью.
* **Опции визуализации**: при помощи опций визуализации можно представлять собранные данные понятным и полезным образом.
Обычно для доступа к этим и другим опциям настройки требуется дэшборд Grafana. Доступ к опциям и параметрам зависит от версии Caretta и Grafana, а также от настроек и потребностей вашей системы.
Интерпретация и использование визуальной карты сети
---------------------------------------------------
Основные задачи визуальной карты сети, созданной Caretta и Grafana — помощь в понимании сетевой топологии, выявлении возможных узких мест или проблем и планировании и устранении сетевых проблем. Чтобы интерпретировать и использовать визуальную карту сети, нужно разобраться в компонентах карты и их значении.
Вот некоторые из типов информации, которые могут отображаться на карте:
* **Устройства**: присутствующие на карте конечные точки сети, в том числе серверы, коммутаторы и роутеры.
* **Соединения**: соединения между устройствами, например, сетевые кабели, беспроводные или виртуальные соединения; иногда тип соединения отображается на карте.
* **Данные**: на карте отображаются показатели производительности, уведомления и информация о конфигурации.
### ▍ Советы по использованию карты сети для оценки производительности кластера K8s
Создание курируемой, информативной и масштабируемой карты сети — довольно сложная задача. Однако при наличии подходящего набора инструментов её вполне можно решить.
Мы уже увидели, чего можно добиться при использовании Caretta и Grafana. Теперь давайте посмотрим, что нужно учитывать при использовании карт сетей, отображающих метрики производительности кластеров Kubernetes.
Первое и самое главное: необходимо понять сетевую топологию кластера, в том числе физические и виртуальные сети, в которых выполняются ваши сервисы. Далее необходимо убедиться, что используемый вами сетевой плагин совместим с вашим приложением. Наконец, установите сетевые политики, чтобы обезопасить обмен данными между подами, контролировать входной и выходной трафик, выполнять мониторинг и устранять неполадки. Разберитесь, как выполняется обмен данными между подами и как устроена сеть подов.
Заключение
----------
Разбиение крупных систем на микросервисы, превращение систем в распределённые и управление ими — самый популярный подход для повышения производительности и аптайма. В этом лидерами рынка стали Kubernetes и Docker.
Несмотря на высокую производительность, проблемой крупномасштабных распределённых сетей является удобство наблюдения. Нам нужно учитывать все важные выбросы и аномалии, чтобы выполнять мониторинг и улучшать систему в целом с учётом оптимальной производительности. Новые технологии упрощают инновации и улучшения, однако вносят в систему неизвестные помехи. Необходим инструмент для наблюдений, способный отслеживать все операции в сети и презентовать их эффективным и информативным образом.
Grafana — лидирующий инструмент на рынке мониторинга. Соединив опенсорсный инструмент сетевой визуализации и мониторинга Caretta с Grafana, можно полностью раскрыть возможности своей инфраструктуры.
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=vizualnye_karty_setej_klasterov_k8s_dlya_ocenki_ix_proizvoditelnosti) | https://habr.com/ru/post/712536/ | null | ru | null |
# Открытый курс машинного обучения. Тема 6. Построение и отбор признаков
Сообщество Open Data Science приветствует участников курса!
В рамках курса мы уже познакомились с несколькими ключевыми алгоритмами машинного обучения. Однако перед тем как переходить к более навороченным алгоритмам и подходам, хочется сделать шаг в сторону и поговорить о подготовке данных для обучения модели. Известный принцип garbage in – garbage out на 100% применим к любой задаче машинного обучения; любой опытный аналитик может вспомнить примеры из практики, когда простая модель, обученная на качественно подготовленных данных, показала себя лучше хитроумного ансамбля, построенного на недостаточно чистых данных.
**UPD 01.2022:** С февраля 2022 г. [ML-курс ODS на русском](https://ods.ai/tracks/open-ml-course) возрождается под руководством Петра Ермакова [couatl](https://habr.com/ru/users/couatl/). Для русскоязычной аудитории это предпочтительный вариант (c этими статьями на Хабре – в подкрепление), англоговорящим рекомендуется [mlcourse.ai](https://mlcourse.ai) в режиме самостоятельного прохождения.
**Список статей серии**
1. [Первичный анализ данных с Pandas](https://habrahabr.ru/company/ods/blog/322626/)
2. [Визуальный анализ данных c Python](https://habrahabr.ru/company/ods/blog/323210/)
3. [Классификация, деревья решений и метод ближайших соседей](https://habrahabr.ru/company/ods/blog/322534/)
4. [Линейные модели классификации и регрессии](https://habrahabr.ru/company/ods/blog/323890/)
5. [Композиции: бэггинг, случайный лес](https://habrahabr.ru/company/ods/blog/324402/)
6. [Построение и отбор признаков](https://habrahabr.ru/company/ods/blog/325422/)
7. [Обучение без учителя: PCA, кластеризация](https://habrahabr.ru/company/ods/blog/325654/)
8. [Обучение на гигабайтах c Vowpal Wabbit](https://habrahabr.ru/company/ods/blog/326418/)
9. [Анализ временных рядов с помощью Python](https://habrahabr.ru/company/ods/blog/327242/)
10. [Градиентный бустинг](https://habrahabr.ru/company/ods/blog/327250/)
В рамках сегодняшней статьи хочется обзорно описать три похожих, но разных задачи:
* feature extraction and feature engineering – превращение данных, специфических для предметной области, в понятные для модели векторы;
* feature transformation – трансформация данных для повышения точности алгоритма;
* feature selection – отсечение ненужных признаков.
Отдельно отмечу, что в этой статье почти не будет формул, зато будет относительно много кода.
В некоторых примерах будет использоваться датасет от компании [Renthop](https://www.renthop.com/), используемого в соревновании [Two Sigma Connect: Rental Listing Inquires](https://www.kaggle.com/c/two-sigma-connect-rental-listing-inquiries) на Kaggle. В этой задаче нужно предсказать популярность объявления об аренде недвижимости, т.е. решить задачу классификации на три класса `['low', 'medium', 'high']`. Для оценки решения используется метрика log loss (чем меньше — тем лучше). Тем, у кого еще нет аккаунта на Kaggle, придется зарегистрироваться; также для скачивания данных нужно принять правила соревнования.
```
# перед началом работы не забудьте скачать файл train.json.zip с Kaggle и разархивировать его
import json
import pandas as pd
# сразу загрузим датасет от Renthop
with open('train.json', 'r') as raw_data:
data = json.load(raw_data)
df = pd.DataFrame(data)
```
* [Извлечение признаков (Feature Extraction)](https://habrahabr.ru/company/ods/blog/325422/#izvlechenie-priznakov-feature-extraction)
+ [Тексты](https://habrahabr.ru/company/ods/blog/325422/#teksty)
+ [Изображения](https://habrahabr.ru/company/ods/blog/325422/#izobrazheniya)
+ [Геоданные](https://habrahabr.ru/company/ods/blog/325422/#geodannye)
+ [Дата и время](https://habrahabr.ru/company/ods/blog/325422/#data-i-vremya)
+ [Временные ряды, веб и прочее](https://habrahabr.ru/company/ods/blog/325422/#vremennye-ryady-veb-i-prochee)
* [Преобразования признаков (Feature transformations)](https://habrahabr.ru/company/ods/blog/325422/#preobrazovaniya-priznakov-feature-transformations)
+ [Нормализация и изменение распределения](https://habrahabr.ru/company/ods/blog/325422/#normalizaciya-i-izmenenie-raspredeleniya)
+ [Взаимодействия (Interactions)](https://habrahabr.ru/company/ods/blog/325422/#vzaimodeystviya-interactions)
+ [Заполнение пропусков](https://habrahabr.ru/company/ods/blog/325422/#zapolnenie-propuskov)
* [Выбор признаков (Feature selection)](https://habrahabr.ru/company/ods/blog/325422/#vybor-priznakov-feature-selection)
+ [Статистические подходы](https://habrahabr.ru/company/ods/blog/325422/#statisticheskie-podhody)
+ [Отбор с использованием моделей](https://habrahabr.ru/company/ods/blog/325422/#otbor-s-ispolzovaniem-modeley)
+ [Перебор](https://habrahabr.ru/company/ods/blog/325422/#perebor)
* [Домашнее задание](https://habrahabr.ru/company/ods/blog/325422/#domashnee-zadanie)
Извлечение признаков (Feature Extraction)
-----------------------------------------
В жизни редко данные приходят в виде готовых матриц, потому любая задача начинается с извлечения признаков. Иногда, конечно, достаточно прочитать csv файл и сконвертировать его в `numpy.array`, но это счастливые исключения. Давайте посмотрим на некоторые популярные типы данных, из которых нужно извлекать признаки.
### Тексты
Текст – самый очевидный пример данных в свободном формате; методов работы с текстом достаточно, чтобы они не уместились в одну статью. Тем не менее, обзорно пройдем по самым популярным.
Перед тем как работать с текстом, его необходимо токенизировать. Токенизация предполагает разбиение текста на токены – в самом простом случае это просто слова. Но, делая это слишком простой регуляркой ("в лоб"), мы можем потерять часть смысла: "Нижний Новгород" это не два токена, а один. Зато призыв "воруй-убивай!" можно напрасно разделить на два токена. Существуют готовые токенайзеры, которые учитывают особенности языка, но и они могут ошибаться, особенно если вы работаете со специфическими текстами (профессиональная лексика, жаргонизмы, опечатки).
После токенизации в большинстве случаев нужно задуматься о приведении к нормальной форме. Речь идет о стемминге и/или лемматизации – это схожие процессы, используемые для обработки словоформ. О разнице между ними можно прочитать [здесь](http://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html).
Итак, мы превратили документ в последовательность слов, можно начинать превращать их в вектора. Самый простой подход называется Bag of Words: создаем вектор длиной в словарь, для каждого слова считаем количество вхождений в текст и подставляем это число на соответствующую позицию в векторе. В коде это выглядит даже проще, чем на словах:
**Bag of Words без лишних библиотек**
```
from functools import reduce
import numpy as np
texts = [['i', 'have', 'a', 'cat'],
['he', 'have', 'a', 'dog'],
['he', 'and', 'i', 'have', 'a', 'cat', 'and', 'a', 'dog']]
dictionary = list(enumerate(set(reduce(lambda x, y: x + y, texts))))
def vectorize(text):
vector = np.zeros(len(dictionary))
for i, word in dictionary:
num = 0
for w in text:
if w == word:
num += 1
if num:
vector[i] = num
return vector
for t in texts:
print(vectorize(t))
```
Также идея хорошо иллюстрируется картинкой:
Это предельно наивная реализация. В реальной жизни нужно позаботиться о стоп-словах, максимальном размере словаря, эффективной структуре данных (обычно текстовые данные превращают в разреженные вектора)…
Используя алгоритмы вроде Вag of Words, мы теряем порядок слов в тексте, а значит, тексты "i have no cows" и "no, i have cows" будут идентичными после векторизации, хотя и противоположными семантически. Чтобы избежать этой проблемы, можно сделать шаг назад и изменить подход к токенизации: например, использовать N-граммы (комбинации из N последовательных терминов).
**Проверим на практике**
```
In : from sklearn.feature_extraction.text import CountVectorizer
In : vect = CountVectorizer(ngram_range=(1,1))
In : vect.fit_transform(['no i have cows', 'i have no cows']).toarray()
Out:
array([[1, 1, 1],
[1, 1, 1]], dtype=int64)
In : vect.vocabulary_
Out: {'cows': 0, 'have': 1, 'no': 2}
In : vect = CountVectorizer(ngram_range=(1,2))
In : vect.fit_transform(['no i have cows', 'i have no cows']).toarray()
Out:
array([[1, 1, 1, 0, 1, 0, 1],
[1, 1, 0, 1, 1, 1, 0]], dtype=int64)
In : vect.vocabulary_
Out:
{'cows': 0,
'have': 1,
'have cows': 2,
'have no': 3,
'no': 4,
'no cows': 5,
'no have': 6}
```
Также отмечу, что необязательно оперировать именно словами: в некоторых случаях можно генерировать N-граммы из букв (например, такой алгоритм учтет сходство родственных слов или опечаток).
```
In : from scipy.spatial.distance import euclidean
In : vect = CountVectorizer(ngram_range=(3,3), analyzer='char_wb')
In : n1, n2, n3, n4 = vect.fit_transform(['иванов', 'петров', 'петренко', 'смит']).toarray()
In : euclidean(n1, n2)
Out: 3.1622776601683795
In : euclidean(n2, n3)
Out: 2.8284271247461903
In : euclidean(n3, n4)
Out: 3.4641016151377544
```
Развитие идеи Bag of Words: слова, которые редко встречаются в корпусе (во всех рассматриваемых документах этого набора данных), но присутствуют в этом конкретном документе, могут оказаться более важными. Тогда имеет смысл повысить вес более узкотематическим словам, чтобы отделить их от общетематических. Этот подход называется TF-IDF, его уже не напишешь в десять строк, потому желающие могут ознакомиться с деталями во внешних источниках вроде [wiki](https://en.wikipedia.org/wiki/Tf%E2%80%93idf). Вариант по умолчанию выглядит так:
Аналоги Bag of words могут встречаться и за пределами текстовых задач: например, bag of sites в [соревновании](https://inclass.kaggle.com/c/catch-me-if-you-can-intruder-detection-through-webpage-session-tracking2), которые мы проводим – Catch Me If You Can. Можно поискать и другие примеры – [bag of apps](https://www.kaggle.com/xiaoml/talkingdata-mobile-user-demographics/bag-of-app-id-python-2-27392), [bag of events](http://www.interdigital.com/download/58540a46e3b9659c9f000372).
Используя такие алгоритмы, можно получить вполне рабочее решение несложной проблемы, эдакий baseline. Впрочем, для нелюбителей классики есть и более новые подходы. Самый распиаренный метод новой волны – Word2Vec, но есть и альтернативы (Glove, Fasttext…).
Word2Vec является частным случаем алгоритмов Word Embedding. Используя Word2Vec и подобные модели, мы можем не только векторизовать слова в пространство большой размерности (обычно несколько сотен), но и сравнивать их семантическую близость. Классический пример операций над векторизированными представлениями: king – man + woman = queen.
Стоит понимать, что эта модель, конечно же, не обладает пониманием слов, а просто пытается разместить вектора таким образом, чтобы слова, употребляемые в общем контексте, размещались недалеко друг от друга. Если это не учитывать, то можно придумать много курьезов: например, найти противоположность Гитлеру путем умножения соответствующего вектора на -1.
Такие модели должны обучаться на очень больших наборах данных, чтобы координаты векторов действительно отражали семантику слов. Для решения своих задач можно скачать предобученную модель, например, [здесь](https://github.com/3Top/word2vec-api#where-to-get-a-pretrained-models).
Похожие методы, кстати, применяются и других областях (например, в биоинформатике). Из совсем неожиданных применений – [food2vec](https://jaan.io/food2vec-augmented-cooking-machine-intelligence/).
### Изображения
В работе с изображениями все и проще, и сложнее одновременно. Проще, потому что часто можно вообще не думать и пользоваться одной из популярных предобученных сетей; сложнее, потому что если нужно все-таки детально разобраться, то эта кроличья нора окажется чертовски глубокой. Впрочем, обо всем по порядку.
Во времена, когда GPU были слабее, а "ренессанс нейросетей" еще не случился, генерация фичей из картинок была отдельной сложной областью. Для работы с картинками нужно было работать на низком уровне, определяя, например, углы, границы областей и так далее. Опытные специалисты в компьютерном зрении могли бы провести много параллелей между более старыми подходами и нейросетевым хипстерством: в частности, сверточные слои в современных сетях очень похожи на [каскады Хаара](https://habrahabr.ru/post/208092/). Не будучи опытным в этом вопросе, не стану даже пытаться передать знание из публичных источников, оставлю пару ссылок на библиотеки [skimage](http://scikit-image.org/docs/stable/api/skimage.feature.html) и [SimpleCV](http://simplecv.readthedocs.io/en/latest/SimpleCV.Features.html) и перейду сразу к нашим дням.
Часто для задач, связанных с картинками, используется какая-нибудь сверточная сеть. Можно не придумывать архитектуру и не обучать сеть с нуля, а взять предобученную state of the art сеть, веса которой можно скачать из открытых источников. Чтобы адаптировать ее под свою задачу, дата сайнтисты практикуют т.н. fine tuning: последние полносвязные слои сети "отрываются", вместо них добавляются новые, подобранные под конкретную задачу, и сеть дообучается на новых данных. Но если вы хотите просто векторизовать изображение для каких-то своих целей (например, использовать какой-то несетевой классификатор) – просто оторвите последние слои и используйте выход предыдущих слоев:
```
from keras.applications.resnet50 import ResNet50
from keras.preprocessing import image
from scipy.misc import face
import numpy as np
resnet_settings = {'include_top': False, 'weights': 'imagenet'}
resnet = ResNet50(**resnet_settings)
img = image.array_to_img(face())
# какой милый енот!
img = img.resize((224, 224))
# в реальной жизни может понадобиться внимательнее относиться к ресайзу
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
# нужно дополнительное измерение, т.к. модель рассчитана на работу с массивом изображений
features = resnet.predict(x)
```
*Классификатор, обученный на одном датасете и адаптированный для другого путем "отрыва" последнего слоя и добавления нового взамен*
Тем не менее, не стоит зацикливаться на нейросетевых методах. Некоторые признаки, сгенерированные руками, могут оказаться полезными и в наши дни: например, предсказывая популярность объявлений об аренде квартиры, можно предположить, что светлые квартиры больше привлекают внимание, и сделать признак "среднее значение пикселя". Вдохновиться примерами можно в [документации соответствующих библиотек](http://pillow.readthedocs.io/en/3.1.x/reference/ImageStat.html).
Если на картинке ожидается текст, его также можно прочитать и не разворачивая своими руками сложную нейросеть: например, при помощи [pytesseract](https://github.com/madmaze/pytesseract).
```
In : import pytesseract
In : from PIL import Image
In : import requests
In : from io import BytesIO
In : img = 'http://ohscurrent.org/wp-content/uploads/2015/09/domus-01-google.jpg'
# просто случайная картинка из поиска
In : img = requests.get(img)
...: img = Image.open(BytesIO(img.content))
...: text = pytesseract.image_to_string(img)
...:
In : text
Out: 'Google'
```
Надо понимать, что pytesseract – далеко не панацея:
```
# на этот раз возьмем картинку от Renthop
In : img = requests.get('https://photos.renthop.com/2/8393298_6acaf11f030217d05f3a5604b9a2f70f.jpg')
...: img = Image.open(BytesIO(img.content))
...: pytesseract.image_to_string(img)
...:
Out: 'Cunveztible to 4}»'
```
Еще один случай, когда нейросети не помогут – извлечение признаков из метаинфорации. А ведь в EXIF может храниться много полезного: производитель и модель камеры, разрешение, использование вспышки, геокоординаты съемки, использованный для обработки софт и многое другое.
### Геоданные
Географические данные не так часто попадаются в задачах, но освоить базовые приемы для работы с ними также полезно, тем более, что в этой сфере тоже хватает готовых решений.
Геоданные чаще всего представлены в виде адресов или пар "широта + долгота", т.е. точек. В зависимости от задачи могут понадобиться две обратные друг другу операции: геокодинг (восстановление точки из адреса) и обратный геокодинг (наоборот). И то, и другое осуществимо при помощи внешних API вроде Google Maps или OpenStreetMap. У разных геокодеров есть свои особенности, качество разнится от региона к региону. К счастью, есть универсальные библиотеки вроде [geopy](https://github.com/geopy/geopy), которые выступают в роли оберток над множеством внешних сервисов.
Если данных много, легко упереться в лимиты внешних API. Да и получать информацию по HTTP – далеко не всегда оптимальное по скорости решение. Поэтому стоит иметь в виду возможность использования локальной версии OpenStreetMap.
Если данных немного, времени хватает, а желания извлекать наворченные признаки нет, то можно не заморачиваться с OpenStreetMap и воспользоваться `reverse_geocoder`:
```
In : import reverse_geocoder as revgc
In : revgc.search((df.latitude, df.longitude))
Loading formatted geocoded file...
Out:
[OrderedDict([('lat', '40.74482'),
('lon', '-73.94875'),
('name', 'Long Island City'),
('admin1', 'New York'),
('admin2', 'Queens County'),
('cc', 'US')])]
```
Работая с геокодингом, нельзя забывать о том, что адреса могут содержать опечатки, соответственно, стоит потратить время на очистку. В координатах опечаток обычно меньше, но и с ними не все хорошо: GPS по природе данных может "шуметь", а в некоторых местах (туннели, кварталы небоскребов...) – довольно сильно. Если источник данных – мобильное устройство, стоит учесть, что в некоторых случаях геолокация определяется не по GPS, а по WiFi сетям в округе, что ведет к дырам в пространстве и телепортации: среди набора точек, описывающих путешествие по Манхеттену может внезапно оказаться одна из Чикаго.
**Гипотезы о телепортации**
WiFi location tracking основан на комбинации SSID и MAC-адреса, которые могут совпадать у совсем разных точек (например, федеральный провайдер стандартизировал прошивку роутеров с точностью до MAC-адреса и размещает их в разных городах). Есть и более банальные причины вроде переезда компании со своими роутерами в другой офис.
Точка обычно находится не в чистом поле, а среди инфраструктуры – здесь можно дать волю фантазии и начать придумывать признаки, применяя жизненный опыт и знание доменной области. Близость точки к метро, этажность застройки, расстояние до ближайшего магазина, количество банкоматов в радиусе – в рамках одной задачи можно придумывать десятки признаков и добывать их из разных внешних источников. Для задач вне городской инфраструктуры могут пригодиться признаки из более специфических источников: например, высота над уровнем моря.
Если две или более точек взаимосвязаны, возможно, стоит извлекать признаки из маршрута между ними. Здесь пригодятся и дистанции (стоит смотреть и на great circle distance, и на "честное" расстояние, посчитанное по дорожному графу), и количество поворотов вместе с соотношением левых и правых, и количество светофоров, развязок, мостов. Например, в одной из моих задач неплохо себя проявил признак, который я назвал "сложность дороги" – расстояние, посчитанное по графу и деленное на GCD.
### Дата и время
Казалось бы, работа с датой и временем должна быть стандартизирована из-за распространенности соответствующих признаков, но подводные камни остаются.
Начнем с дней недели – их легко превратить в 7 dummy переменных при помощи one-hot кодирования. Кроме этого, полезно выделить отдельный признак для выходных.
```
df['dow'] = df['created'].apply(lambda x: x.date().weekday())
df['is_weekend'] = df['created'].apply(lambda x: 1 if x.date().weekday() in (5, 6) else 0)
```
В некоторых задачах могут понадобиться дополнительные календарные признаки: например, снятие наличных денег может быть привязано к дню выдачи зарплат, а покупка проездного – к началу месяца. А по-хорошему, работая с временными данными, надо иметь под рукой календарь с государственными праздниками, аномальными погодными условиями и другими важными событиями.
**Профессиональный несмешной юмор**
* Что общего между китайским новым годом, нью-йорским марафоном, гей-парадом и инаугурацией Трампа?
* Их все нужно внести в календарь потенциальных аномалий.
А вот с часом (минутой, днем месяца...) все не так радужно. Если использовать час как вещественную переменную, мы немного противоречим природе данных: 0 < 23, хотя 02.01 0:00:00 > 01.01 23:00:00. Для некоторых задач это может оказаться критично. Если же кодировать их как категориальные переменные, можно наплодить кучу признаков и потерять информацию о близости: разница между 22 и 23 будет такой же, как и между 22 и 7.
Есть и более эзотерические подходы к таким данным. Например, проекция на окружность с последующим использованием двух координат.
```
def make_harmonic_features(value, period=24):
value *= 2 * np.pi / period
return np.cos(value), np.sin(value)
```
Такое преобразование сохраняет дистанцию между точками, что важно для некоторых алгоритмов, основанных на расстоянии (kNN, SVM, k-means...)
```
In : from scipy.spatial import distance
In : euclidean(make_harmonic_features(23), make_harmonic_features(1))
Out: 0.5176380902050424
In : euclidean(make_harmonic_features(9), make_harmonic_features(11))
Out: 0.5176380902050414
In : euclidean(make_harmonic_features(9), make_harmonic_features(21))
Out: 2.0
```
Впрочем, разницу между такими способами кодирования обычно можно уловить только в третьем знаке после запятой в метрике, не раньше.
### Временные ряды, веб и прочее
Мне не довелось вдоволь поработать с временными рядами, потому я оставлю ссылку на [библиотеку для автоматической генерации признаков из временных рядов](https://github.com/blue-yonder/tsfresh) и пойду дальше.
Если вы работаете с вебом, то у вас обычно есть информация про User Agent пользователя. Это кладезь информации.
Во-первых, оттуда в первую очередь нужно извлечь операционную систему. Во-вторых, сделать признак `is_mobile`. В-третьих, посмотреть на браузер.
**Пример извлечения признаков из юзер-агента**
```
In : ua = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/56.0.2924.76 Chrome/
...: 56.0.2924.76 Safari/537.36'
In : import user_agents
In : ua = user_agents.parse(ua)
In : ua.is_bot
Out: False
In : ua.is_mobile
Out: False
In : ua.is_pc
Out: True
In : ua.os.family
Out: 'Ubuntu'
In : ua.os.version
Out: ()
In : ua.browser.family
Out: 'Chromium'
In : ua.os.version
Out: ()
In : ua.browser.version
Out: (56, 0, 2924)
```
Как и в других доменных областях, можно придумывать свои признаки, основываясь на догадках о природе данных. На момент написания статьи Chromium 56 был новым, а через какое-то время такая версия браузера сможет сохраниться только у тех, кто очень давно не перезагружал этот самый браузер. Почему бы в таком случае не ввести признак "отставание от свежей версии браузера"?
Кроме ОС и браузера, можно посмотреть на реферер (доступен не всегда), [http\_accept\_language](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language) и другую метаинформацию.
Следующая по полезности информация – IP-адрес, из которого можно извлечь как минимум страну, а желательно еще город, провайдера, тип подключения (мобильное / стационарное). Нужно понимать, что бывают разнообразные прокси и устаревшие базы, так что признак может содержать шум. Гуру сетевого администрирования могут попробовать извлекать и гораздо более навороченные признаки: например, строить предположения об [использовании VPN](https://habrahabr.ru/post/216295/). Кстати, данные из IP-адреса неплохо комбинировать с http\_accept\_language: если пользователь сидит за чилийским прокси, а локаль браузера – ru\_RU, что-то здесь нечисто и достойно единицы в соответствующей колонке в таблице (`is_traveler_or_proxy_user`).
Вообще, доменной специфики в той или иной области настолько много, что в одной голове ей не уместиться. Потому я призываю уважаемых читателей поделиться опытом и рассказать в комментариях об извлечении и генерации признаков в своей работе.
Преобразования признаков (Feature transformations)
--------------------------------------------------
### Нормализация и изменение распределения
Монотонное преобразование признаков критично для одних алгоритмов и не оказывает влияния на другие. Кстати, это одна из причин популярности деревьев решений и всех производных алгоритмов (случайный лес, градиентный бустинг) – не все умеют/хотят возиться с преобразованиями, а эти алгоритмы устойчивы к необычным распределениям.
Бывают и сугубо инженерные причины: `np.log` как способ борьбы со слишком большими числами, не помещающимися в `np.float64`. Но это скорее исключение, чем правило; чаще все-таки вызвано желанием адаптировать датасет под требования алгоритма. Параметрические методы обычно требуют как минимум симметричного и унимодального распределения данных, что не всегда обеспечивается реальным миром. Могут быть и более строгие требования (уместно вспомнить [урок про линейные модели](https://habrahabr.ru/company/ods/blog/323890/#1-lineynaya-regressiya)).
Впрочем, требования к данным предъявляют не только параметрические методы: тот же [метод ближайших соседей](https://habrahabr.ru/company/ods/blog/322534/#metod-blizhayshih-sosedey) предскажет полную чушь, если признаки ненормированы: одно распределение расположено в районе нуля и не выходит за пределы (-1, 1), а другой признак – это сотни и тысячи.
Простой пример: предположим, что стоит задача предсказать стоимость квартиры по двум признакам – удаленности от центра и количеству комнат. Количество комнат редко превосходит 5, а расстояние от центра в больших городах легко может измеряться в десятках тысяч метров.
Самая простая трансформация – это Standart Scaling (она же Z-score normalization).
StandartScaling хоть и не делает распределение нормальным в строгом смысле слова...
```
In : from sklearn.preprocessing import StandardScaler
In : from scipy.stats import beta
In : from scipy.stats import shapiro
In : data = beta(1, 10).rvs(1000).reshape(-1, 1)
In : shapiro(data)
Out: (0.8783774375915527, 3.0409122263582326e-27)
# значение статистики, p-value
In : shapiro(StandardScaler().fit_transform(data))
Out: (0.8783774375915527, 3.0409122263582326e-27)
# с таким p-value придется отклонять нулевую гипотезу о нормальности данных
```
… но в какой-то мере защищает от выбросов
```
In : data = np.array([1, 1, 0, -1, 2, 1, 2, 3, -2, 4, 100]).reshape(-1, 1).astype(np.float64)
In : StandardScaler().fit_transform(data)
Out:
array([[-0.31922662],
[-0.31922662],
[-0.35434155],
[-0.38945648],
[-0.28411169],
[-0.31922662],
[-0.28411169],
[-0.24899676],
[-0.42457141],
[-0.21388184],
[ 3.15715128]])
In : (data – data.mean()) / data.std()
Out:
array([[-0.31922662],
[-0.31922662],
[-0.35434155],
[-0.38945648],
[-0.28411169],
[-0.31922662],
[-0.28411169],
[-0.24899676],
[-0.42457141],
[-0.21388184],
[ 3.15715128]])
```
Другой достаточно популярный вариант – MinMax Scaling, который переносит все точки на заданный отрезок (обычно (0, 1)).
```
In : from sklearn.preprocessing import MinMaxScaler
In : MinMaxScaler().fit_transform(data)
Out:
array([[ 0.02941176],
[ 0.02941176],
[ 0.01960784],
[ 0.00980392],
[ 0.03921569],
[ 0.02941176],
[ 0.03921569],
[ 0.04901961],
[ 0. ],
[ 0.05882353],
[ 1. ]])
In : (data – data.min()) / (data.max() – data.min())
Out:
array([[ 0.02941176],
[ 0.02941176],
[ 0.01960784],
[ 0.00980392],
[ 0.03921569],
[ 0.02941176],
[ 0.03921569],
[ 0.04901961],
[ 0. ],
[ 0.05882353],
[ 1. ]])
```
StandartScaling и MinMax Scaling имеют похожие области применимости и часто сколько-нибудь взаимозаменимы. Впрочем, если алгоритм предполагает вычисление расстояний между точками или векторами, выбор по умолчанию – StandartScaling. Зато MinMax Scaling полезен для визуализации, чтобы перенести признаки на отрезок (0, 255).
Если мы предполагаем, что некоторые данные не распределены нормально, зато описываются [логнормальным распределением](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5), их можно легко привести к честному нормальному распределению:
```
In : from scipy.stats import lognorm
In : data = lognorm(s=1).rvs(1000)
In : shapiro(data)
Out: (0.05714237689971924, 0.0)
In : shapiro(np.log(data))
Out: (0.9980740547180176, 0.3150389492511749)
```
Логнормальное распределение подходит для описания зарплат, стоимости ценных бумаг, населения городов, количества комментариев к статьям в интернете и т.п. Впрочем, для применения такого приема распределение не обязательно должно быть именно логнормальным – все распределения с тяжелым правым хвостом можно пробовать подвергнуть такому преобразованию. Кроме того, можно пробовать применять и другие похожие преобразования, ориентируясь на собственные гипотезы о том, как приблизить имеющееся распределение к нормальному. Примерами таких трансформаций являются [преобразование Бокса-Кокса](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.boxcox.html) (логарифмирование – это частный случай трансформации Бокса-Кокса) или [преобразование Йео-Джонсона](https://gist.github.com/mesgarpour/f24769cd186e2db853957b10ff6b7a95), расширяющее область применимости на отрицательные числа; кроме того, можно пробовать просто добавлять константу к признаку – `np.log(x + const)`.
В примерах выше мы работали с синтетическими данными и строго проверяли нормальность при помощи критерия Шапиро-Уилка. Давайте попробуем посмотреть на реальные данные, а для проверки на нормальность будем использовать менее формальный метод – [Q-Q график](https://en.wikipedia.org/wiki/Q%E2%80%93Q_plot). Для нормального распределения он будет выглядеть как ровная диагональная линия, и визуальные отклонения интуитивно понятны.
*Q-Q график для логнормального распределения*
*Q-Q график для того же распределения после логарифмирования*
**Давайте рисовать графики!**
```
In : import statsmodels.api as sm
# возьмем признак price из датасета Renthop и пофильтруем руками совсем экстремальные значения для наглядности
In : price = df.price[(df.price <= 20000) & (df.price > 500)]
In : price_log = np.log(price)
In : price_mm = MinMaxScaler().fit_transform(price.values.reshape(-1, 1).astype(np.float64)).flatten()
# много телодвижений, чтобы sklearn не сыпал warning-ами
In : price_z = StandardScaler().fit_transform(price.values.reshape(-1, 1).astype(np.float64)).flatten()
In : sm.qqplot(price_log, loc=price_log.mean(), scale=price_log.std()).savefig('qq_price_log.png')
In : sm.qqplot(price_mm, loc=price_mm.mean(), scale=price_mm.std()).savefig('qq_price_mm.png')
In : sm.qqplot(price_z, loc=price_z.mean(), scale=price_z.std()).savefig('qq_price_z.png')
```
*Q-Q график исходного признака*
*Q-Q график признака после StandartScaler. Форма не меняется*
*Q-Q график признака после MinMaxScaler. Форма не меняется*
*Q-Q график признака после логарифмирования. Дела пошли на поправку!*
Давайте посмотрим, могут ли преобразования как-то помочь реальной модели. Я сделал [небольшой скрипт](https://github.com/Yorko/mlcourse.ai/blob/main/jupyter_russian/topic06_features/demo.py), который читает данные соревнования Renthop, выбирает некоторые признаки (остальные по-диктаторски выброшены для простоты), и возвращает нам более или менее готовые данные для демонстрации.
**Довольно много кода**
```
In : from demo import get_data
In : x_data, y_data = get_data()
In : x_data.head(5)
Out:
bathrooms bedrooms price dishwasher doorman pets \
10 1.5 3 8.006368 0 0 0
10000 1.0 2 8.606119 0 1 1
100004 1.0 1 7.955074 1 0 1
100007 1.0 1 8.094073 0 0 0
100013 1.0 4 8.116716 0 0 0
air_conditioning parking balcony bike ... stainless \
10 0 0 0 0 ... 0
10000 0 0 0 0 ... 0
100004 0 0 0 0 ... 0
100007 0 0 0 0 ... 0
100013 0 0 0 0 ... 0
simplex public num_photos num_features listing_age room_dif \
10 0 0 5 0 278 1.5
10000 0 0 11 57 290 1.0
100004 0 0 8 72 346 0.0
100007 0 0 3 22 345 0.0
100013 0 0 3 7 335 3.0
room_sum price_per_room bedrooms_share
10 4.5 666.666667 0.666667
10000 3.0 1821.666667 0.666667
100004 2.0 1425.000000 0.500000
100007 2.0 1637.500000 0.500000
100013 5.0 670.000000 0.800000
[5 rows x 46 columns]
In : x_data = x_data.values
In : from sklearn.linear_model import LogisticRegression
In : from sklearn.ensemble import RandomForestClassifier
In : from sklearn.model_selection import cross_val_score
In : from sklearn.feature_selection import SelectFromModel
In : cross_val_score(LogisticRegression(), x_data, y_data, scoring='neg_log_loss').mean()
/home/arseny/.pyenv/versions/3.6.0/lib/python3.6/site-packages/sklearn/linear_model/base.py:352: RuntimeWarning: overflow encountered in exp
np.exp(prob, prob)
# кажется, что-то пошло не так! вообще-то стоит разобраться, в чем проблема
Out: -0.68715971821885724
In : from sklearn.preprocessing import StandardScaler
In : cross_val_score(LogisticRegression(), StandardScaler().fit_transform(x_data), y_data, scoring='neg_log_loss').mean()
/home/arseny/.pyenv/versions/3.6.0/lib/python3.6/site-packages/sklearn/linear_model/base.py:352: RuntimeWarning: overflow encountered in exp
np.exp(prob, prob)
Out: -0.66985167834479187
# ого! действительно помогает!
In : from sklearn.preprocessing import MinMaxScaler
In : cross_val_score(LogisticRegression(), MinMaxScaler().fit_transform(x_data), y_data, scoring='neg_log_loss').mean()
...:
Out: -0.68522489913898188
# a на этот раз – нет :(
```
### Взаимодействия (Interactions)
Если предыдущие преобразования диктовались скорее математикой, то этот пункт снова обоснован природой данных; его можно отнести как к трансформациям, так и к созданию новых признаков.
Снова обратимся к задаче Two Sigma Connect: Rental Listing Inquires. Среди признаков в этой задаче есть количество комнат и стоимость аренды. Житейская логика подсказывает, что стоимость в пересчете на одну комнату более показательна, чем общая стоимость – значит, можно попробовать выделить такой признак.
```
rooms = df["bedrooms"].apply(lambda x: max(x, .5))
# избегаем деления на ноль; .5 выбран более или менее произвольно
df["price_per_bedroom"] = df["price"] / rooms
```
Необязательно руководствоваться жизненной логикой. Если признаков не очень много, вполне можно сгенерировать все возможные взаимодействия и потом отсеять лишние, используя одну из техник, описанных в следующем разделе. Кроме того, не все взаимодействия между признаками должны иметь хоть какой-то физический смысл: например, (часто используемые для линейных моделей)[<https://habrahabr.ru/company/ods/blog/322076/>] полиномиальные признаки (см. [`sklearn.preprocessing.PolynomialFeatures`](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html)) трактовать практически невозможно.
### Заполнение пропусков
Не многие алгоритмы умеют работать с пропущенными значениями "из коробки", а реальный мир часто поставляет данные с пропусками. К счастью, это одна из тех задач, для решения которых не нужно никакого творчества. Обе ключевые для анализа данных python библиотеки предоставляют простые как валенок решения: [`pandas.DataFrame.fillna`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.fillna.html) и [`sklearn.preprocessing.Imputer`](http://scikit-learn.org/stable/modules/preprocessing.html#imputation).
Готовые библиотечные решения не прячут никакой магии за фасадом. Подходы к обработке отсутствующих значений напрашиваются на уровне здравого смысла:
* закодировать отдельным пустым значением типа `"n/a"` (для категориальных переменных);
* использовать наиболее вероятное значение признака (среднее или медиану для вещественных переменных, самое частое для категориальных);
* наоборот, закодировать каким-то невероятным значением (хорошо заходит для моделей, основанных на деревьях решений, т.к. позволяет сделать разделение на пропущенные и непропущенные значения);
* для упорядоченных данных (например, временных рядов) можно брать соседнее значение – следующее или предыдущее.
Удобство использования библиотечных решений иногда подсказывает воткнуть что-то вроде `df = df.fillna(0)` и не париться о пропусках. Но это не самое разумное решение: большая часть времени обычно уходит не на построение модели, а на подготовку данных; бездумное неявное заполнение пропусков может спрятать баг в обработке и испортить модель.
Выбор признаков (Feature selection)
-----------------------------------
Зачем вообще может понадобиться выбирать фичи? Кому-то эта идея может показаться контринтуитивной, но на самом деле есть минимум две важные причины избавляться от неважных признаков. Первая понятна всякому инженеру: чем больше данных, тем выше вычислительная сложность. Пока мы балуемся с игрушечными датасетами, размер данных – это не проблема, а для реального нагруженного продакшена лишние сотни признаков могут быть ощутимы. Другая причина – некоторые алгоритмы принимают шум (неинформативные признаки) за сигнал, переобучаясь.
### Статистические подходы
Самый очевидный кандидат на отстрел – признак, у которого значение неизменно, т.е. не содержит вообще никакой информации. Если немного отойти от этого вырожденного случая, резонно предположить, что низковариативные признаки скорее хуже, чем высоковариативные. Так можно придти к идее отсекать признаки, дисперсия которых ниже определенной границы.
```
In : from sklearn.feature_selection import VarianceThreshold
In : from sklearn.datasets import make_classification
In : x_data_generated, y_data_generated = make_classification()
In : x_data_generated.shape
Out: (100, 20)
In : VarianceThreshold(.7).fit_transform(x_data_generated).shape
Out: (100, 19)
In : VarianceThreshold(.8).fit_transform(x_data_generated).shape
Out: (100, 18)
In : VarianceThreshold(.9).fit_transform(x_data_generated).shape
Out: (100, 15)
```
Есть и другие способы, также [основанные на классической статистике](http://scikit-learn.org/stable/modules/feature_selection.html#univariate-feature-selection).
```
In : from sklearn.feature_selection import SelectKBest, f_classif
In : x_data_kbest = SelectKBest(f_classif, k=5).fit_transform(x_data_generated, y_data_generated)
In : x_data_varth = VarianceThreshold(.9).fit_transform(x_data_generated)
In : from sklearn.linear_model import LogisticRegression
In : from sklearn.model_selection import cross_val_score
In : cross_val_score(LogisticRegression(), x_data_generated, y_data_generated, scoring='neg_log_loss').mean()
Out: -0.45367136377981693
In : cross_val_score(LogisticRegression(), x_data_kbest, y_data_generated, scoring='neg_log_loss').mean()
Out: -0.35775228616521798
In : cross_val_score(LogisticRegression(), x_data_varth, y_data_generated, scoring='neg_log_loss').mean()
Out: -0.44033042718359772
```
Видно, что отобранные фичи повысили качество классификатора. Понятно, что этот пример *сугубо* искусственный, тем не менее, прием достоин проверки и в реальных задачах.
### Отбор с использованием моделей
Другой подход: использовать какую-то baseline модель для оценки признаков, при этом модель должна явно показывать важность использованных признаков. Обычно используются два типа моделей: какая-нибудь "деревянная" композиция (например, Random Forest) или линейная модель с Lasso регуляризацией, склонной обнулять веса слабых признаков. Логика интутивно понятна: если признаки явно бесполезны в простой модели, то не надо тянуть их и в более сложную.
**Синтетический пример**
```
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
x_data_generated, y_data_generated = make_classification()
pipe = make_pipeline(SelectFromModel(estimator=RandomForestClassifier()),
LogisticRegression())
lr = LogisticRegression()
rf = RandomForestClassifier()
print(cross_val_score(lr, x_data_generated, y_data_generated, scoring='neg_log_loss').mean())
print(cross_val_score(rf, x_data_generated, y_data_generated, scoring='neg_log_loss').mean())
print(cross_val_score(pipe, x_data_generated, y_data_generated, scoring='neg_log_loss').mean())
-0.184853179322
-0.235652626736
-0.158372952933
```
Нельзя забывать, что это тоже не серебряная пуля — может получиться даже хуже.
**Давайте вернемся к датасету Renthop.**
```
x_data, y_data = get_data()
x_data = x_data.values
pipe1 = make_pipeline(StandardScaler(),
SelectFromModel(estimator=RandomForestClassifier()),
LogisticRegression())
pipe2 = make_pipeline(StandardScaler(),
LogisticRegression())
rf = RandomForestClassifier()
print('LR + selection: ', cross_val_score(pipe1, x_data, y_data, scoring='neg_log_loss').mean())
print('LR: ', cross_val_score(pipe2, x_data, y_data, scoring='neg_log_loss').mean())
print('RF: ', cross_val_score(rf, x_data, y_data, scoring='neg_log_loss').mean())
LR + selection: -0.714208124619
LR: -0.669572736183
# стало только хуже!
RF: -2.13486716798
```
### Перебор
Наконец, самый надежный, но и самый вычислительно сложный способ основан на банальном переборе: обучаем модель на подмножестве "фичей", запоминаем результат, повторяем для разных подмножеств, сравниваем качество моделей. Такой подход называется [Exhaustive Feature Selection](http://rasbt.github.io/mlxtend/user_guide/feature_selection/ExhaustiveFeatureSelector/).
Перебирать все комбинации – обычно слишком долго, так что можно пробовать уменьшить пространство перебора. Фиксируем небольшое число N, перебираем все комбинации по N признаков, выбираем лучшую комбинацию, потом перебираем комбинации из N+1 признаков так, что предыдущая лучшая комбинация признаков зафиксирована, а перебирается только новый признак. Таким образом можно перебирать, пока не упремся в максимально допустимое число признаков или пока качество модели не перестанет значимо расти. Этот алгоритм называется [Sequential Feature Selection](http://rasbt.github.io/mlxtend/user_guide/feature_selection/SequentialFeatureSelector/).
Этот же алгоритм можно развернуть: начинать с полного пространства признаков и выкидывать признаки по одному, пока это не портит качество модели или пока не достигнуто желаемое число признаков.
**Время неспешного перебора!**
```
In : selector = SequentialFeatureSelector(LogisticRegression(), scoring='neg_log_loss', verbose=2, k_features=3, forward=False, n_jobs=-1)
In : selector.fit(x_data_scaled, y_data)
In : selector.fit(x_data_scaled, y_data)
[2017-03-30 01:42:24] Features: 45/3 -- score: -0.682830838803
[2017-03-30 01:44:40] Features: 44/3 -- score: -0.682779463265
[2017-03-30 01:46:47] Features: 43/3 -- score: -0.682727480522
[2017-03-30 01:48:54] Features: 42/3 -- score: -0.682680521828
[2017-03-30 01:50:52] Features: 41/3 -- score: -0.68264297879
[2017-03-30 01:52:46] Features: 40/3 -- score: -0.682607753617
[2017-03-30 01:54:37] Features: 39/3 -- score: -0.682570678346
[2017-03-30 01:56:21] Features: 38/3 -- score: -0.682536314625
[2017-03-30 01:58:02] Features: 37/3 -- score: -0.682520258804
[2017-03-30 01:59:39] Features: 36/3 -- score: -0.68250862986
[2017-03-30 02:01:17] Features: 35/3 -- score: -0.682498213174
# "Вечерело. А старушки все падали и падали..."
...
[2017-03-30 02:21:09] Features: 10/3 -- score: -0.68657335969
[2017-03-30 02:21:18] Features: 9/3 -- score: -0.688405548594
[2017-03-30 02:21:26] Features: 8/3 -- score: -0.690213724719
[2017-03-30 02:21:32] Features: 7/3 -- score: -0.692383588303
[2017-03-30 02:21:36] Features: 6/3 -- score: -0.695321584506
[2017-03-30 02:21:40] Features: 5/3 -- score: -0.698519960477
[2017-03-30 02:21:42] Features: 4/3 -- score: -0.704095390444
[2017-03-30 02:21:44] Features: 3/3 -- score: -0.713788301404
# но улучшение не могло продолжаться вечно
```
Домашнее задание №6
-------------------
В рамках самостоятельной работы предлагается поработать c задачей регрессии на примере набора данных репозитория UCI про качество разных сортов вина. Заполните недостающий код в [Jupyter notebook](http://nbviewer.jupyter.org/github/Yorko/mlcourse.ai/blob/main/jupyter_russian/assignments_demo/assignment06_regression_wine.ipynb) и выберите ответы в [веб-форме](https://docs.google.com/forms/d/1gsNxgkd0VqidZp4lh9mnCQnJw3b0IFR1C4WBES86J40/edit), там же найдете и решение.
Актуальные и обновляемые версии демо-заданий – на английском на сайте курса, [вот первое задание](https://mlcourse.ai/book/topic01/assignment01_pandas_uci_adult.html). Также по подписке на Patreon (["Bonus Assignments" tier](https://www.patreon.com/ods_mlcourse)) доступны [расширенные домашние задания](https://mlcourse.ai/book/index.html#bonus-assignments) по каждой теме (только на англ.).
Полезные источники
------------------
* [Open Machine Learning Course. Topic 6. Feature Engineering and Feature Selection](https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-6-feature-engineering-and-feature-selection-8b94f870706a)
* [Kaggle Kernels](https://www.kaggle.com/kernels)
* ["Feature Engineering Book"](https://github.com/alicezheng/feature-engineering-book)
* Статья на Хабре ["Feature Engineering, о чём молчат online-курсы"](https://habrahabr.ru/company/mailru/blog/346942/) | https://habr.com/ru/post/325422/ | null | ru | null |
# Мониторинг запросов в Greenplum
О чем статья?
-------------
Всем привет. Меня зовут Дмитрий, я системный архитектор в компании Arenadata, проектирую и разрабатываю системы мониторинга запросов ADCC (Arenadata Command Center) для Arenadata DB.
Часто при работе с разными базами данных необходимо отслеживать выполнение текущих запросов. В основном это связано с задачами администрирования или аналитики. Средства мониторинга, позволяющие управлять и наблюдать за выполнением запросов, сильно помогают в этом. Я расскажу о том, с какими задачами мы столкнулись при проектировании и реализации системы мониторинга запросов для Arenadata DB.
Arenadata DB — это аналитическая распределённая MPP-СУБД с открытым исходным кодом, [построенная на основе СУБД Greenplum](https://habr.com/ru/company/croc/blog/485896/). В связи с этим мониторинг запросов сильно усложняется, потому что выполняются они на множестве сегментов. При этом нагрузка на каждый сегмент зависит от равномерности распределения данных и типов операций, выполняемых над ними. Прямым аналогом ADCC является система VMware Tanzu Greenplum Command Center, которая входит в состав платной версии платформы.
Я буду говорить о второй версии ADCC. Функциональные требования в новой версии по большей части остались прежними, однако были существенно повышены нефункциональные требования, которые кратко можно выразить известной триадой: производительность, отказоустойчивость, расширяемость. Это повлекло за собой глубокие изменения архитектуры; система фактически была переписана с нуля.
В результате получилось решение для детального мониторинга распределенной системы обработки данных.
### Анализ архитектуры
Начали мы с анализа системной архитектуры первой версии ADCC. После изучения работы системы и кодовой базы составили диаграмму системной архитектуры.
 Здесь:
* **Extensions** — набор расширений Arenadata DB, собирающих метрики состояния запросов, блокировок, spill-файлов и пр. Написан на С.
* **Agent** — сервис получения и обработки метрик, написанный на C++. Собирает сообщения, состоящие из нескольких UDP-пакетов. Агент устанавливается в единственном экземпляре на каждый хост (т.е. один агент обрабатывает метрики со всех сегментов в рамках одного хоста).
* **Router** — обратный прокси-сервер для маршрутизации UI-запросов и метрик.
* **Web Server** — основное приложение, которое отвечает за прием, фильтрацию, обработку и сохранение метрик. Также обрабатывает запросы от Web UI (который является частью Web Server) и отправляет на него обновления при помощи websockets.
* **Database** — экземпляр PostgreSQL, в котором хранятся все данные по запросам.
Процесс обработки метрик:
 Упрощенно работу системы можно описать так:
1. Модуль Extensions получает метрики различных типов, формирует на их основе сообщения в формате protocol buffers, разделяет каждое сообщение на части размером не больше датаграммы UDP, и отправляет их агенту на локальном хосте по UDS-сокету либо по UDP-сокету.
2. Agent восстанавливает из полученных датаграмм protobuf-сообщения и пересылает их по протоколу HTTP 1.1 в Web Server.
3. Web Server обрабатывает каждое сообщение в отдельности:
* отправляет полученную метрику на Web UI;
* асинхронно записывает новые данные в базу данных.
Основные проблемы этой архитектуры:
* Есть немасштабируемое приложение (Web Server) для обработки метрик, получаемых с горизонтально масштабируемой системы. Более того, это же приложение обрабатывает пользовательские запросы и шлет обновления на Web UI через websockets.
* Agent принимает и разбирает пакеты в одном потоке, что влияет на производительность как самого агента, так и сегментов на хосте из-за синхронной работы при отправке через UDS-сокет.
* Agentотправляет сообщения на Web Server синхронно, что может влиять на производительность агента и сегментов, если Web Server недоступен, потому что на агенте быстро заполняются внутренние очереди сообщений.
* Каждая метрика порождает отдельную транзакцию на запись в базу данных.
* Если есть активные пользовательские сессии, то многие метрики отправляются по websockets на Web UI по одной.
* Значительная часть метрик просто игнорируется на стороне Web Server. Для примера можно привести сообщения со статусом запроса. В этом случае учитываются только статусы, полученные от сегмента-координатора. При прогоне тестов оказалось, что из общего количества в 872 906 сообщений учитывалось менее 10 % из них (82 963). В итоге имеем лишнюю нагрузку на сеть и все компоненты системы.
Естественно, в этой схеме есть и другие проблемы, но их решение уже не сильно влияло на изначальную цель.
### Немного о реализации расширения
Я упоминал о компоненте Extensions, но не уточнял, как он устроен и какие причины стоят за особенностями его работы.
Extensions — это два компонента Arenadata DB: [gpperfmon](https://github.com/greenplum-db/gpdb/tree/6X_STABLE/gpAux/gpperfmon) и расширение Arenadata DB — gpADCC. Они собирают внутреннюю телеметрию Arenadata DB, которая включает:
* план запроса;
* параметры исполнения запроса в целом;
* параметры работы узлов запроса;
* блокировки объектов базы данных;
* выгруженные на диск временные данные запроса, и др.
Сбор метрик выполняется двумя подходами — push- и pull-моделью.
#### Перехватчики
Сбор данных в push-модели выполняют перехватчики (hooks). В случае Arenadata DB (и PostgreSQL) перехватчик — это указатель на функцию, который может быть изменён расширениями. Функция вызывается в определенных местах, которые можно проинспектировать, а результат отправить вовне.
Перехватчики имеют доступ ко всей памяти процесса, который исполняет запрос; притом этот доступ безопасный и не требует блокировок: перехватчик вызывается в основном потоке исполнения. Вызов в основном потоке позволяет получать данные немедленно, на заранее известной стадии исполнения запроса. Однако это их же недостаток в случае ADCC: каждая инструкция перехватчика отнимает процессорное время у процесса исполнения запроса. Если действовать неаккуратно, то перехватчики замедлят работу системы, для мониторинга которой они предназначены.
В ADCC большинство параметров собираются перехватчиками в push-модели. Поэтому для взаимодействия Extensions и Agent используется протокол UDP: можно отправлять метрики, не дожидаясь подтверждения их получения от Agent. Благодаря этому гарантируется, что максимальное время исполнения каждого перехватчика конечно.
Несколько реальных перехватчиков в PostgreSQL, используемых ADCC на практике:
* [ExecutorStart\_hook](https://github.com/postgres/postgres/blob/30ffdd24d7222bc01183a56d536c236240674516/src/include/executor/executor.h#L78). Начинает исполнение SQL-команды. Позволяет изменять процесс начала исполнения SQL-команды (после планирования). ADCC использует этот hook для получения плана SQL-команды, а также определяет её уникальный идентификатор, который будет использоваться и далее.
* [ExecutorRun\_hook](https://github.com/postgres/postgres/blob/30ffdd24d7222bc01183a56d536c236240674516/src/include/executor/executor.h#L84). Исполняет запрос. Вызывается однократно. В ADCC используется для сбора статуса запроса; фактически, запрос начинает выполняться уже при вызове ExecutorStart\_hook.
* [ExecutorEnd\_hook](https://github.com/postgres/postgres/blob/30ffdd24d7222bc01183a56d536c236240674516/src/include/executor/executor.h#L92). Завершает исполнение запроса. Вызывается только в случае нормального завершения, когда ошибок при выполнении не произошло. В случае аварийного завершения этот перехватчик не вызывается. В ADCC используется для сбора статуса запроса.
#### Процессы периодического сбора метрик
Pull-модель — это использование отдельного процесса, собирающего метрики по запросу или периодически. ADCC для этого использует Background Worker, отдельный процесс экземпляра Arenadata DB, запускаемый и останавливаемый совместно с основным процессом СУБД.
Отдельный процесс может собирать метрики асинхронно, минимально влияя на работу системы. Но есть нюанс: для сбора могут требоваться блокировки (эксклюзивный доступ к ресурсам, например, переменной); в результате мониторинг может полностью парализовать работу системы. Недостаток pull-модели: параметры снимаются не в реальном времени, а с задержкой (равной периоду сбора метрик или задержке между отправкой запроса о сборе метрик и началом сбора).
Background Worker в ADCC собирает данные (список блокировок и другую информацию) с помощью SQL-запросов. Запросы исполняются периодически, с определяемым пользователями периодом. Для единообразия протокол взаимодействия с Agent тот же, что в перехватчиках.
### Данные
Далее мы занялись исследованием состава данных и их объемов, которые снимаются с Arenadata DB для средств мониторинга. Метрики могут быть переданы через два типа сокетов: UDS и UDP (последний используется, если недоступен первый). Из-за ограничения размера одного пакета для UDP (чуть менее 64 Кб для Linux) используется собственный протокол разделения сообщений на части и их последующей сборки.
Чтобы собрать полезную нагрузку, мы отключили передачу данных по UDS, запустили регрессионные тесты и при помощи утилиты *tcpdump* сняли дампы файлов с сообщениями на мастере и одном сегменте. Далее полученные файлы можно было использовать как источники данных с помощью [udpreplay](https://github.com/rigtorp/udpreplay).
Анализ дампов показал следующее:
* нужны не все метрики, собираемые расширениями;
* нагрузка неравномерна по времени;
* средняя нагрузка составила 1650 пакетов/с. или 1 Кбит/с, пиковая нагрузка достигала 45000 пакетов в секунду или 52 Кбит/с.;
* некоторые типы сообщений бывают очень большого объема (порядка 50 Мб, это сообщения с планом запроса в виде форматированной строки).
Имеем неприятные последствия:
* Значительную часть метрик можно отфильтровывать до отправки, а мы этого не сделали.
* В случае отправки по UDP часть пакетов теряется на сетевом уровне при пиковых нагрузках.
* Если хотя бы один пакет сообщения не был доставлен (если размер всего сообщения не умещается в один UDP-пакет), то всё сообщение не может быть восстановлено, а уже принятые пакеты подолгу занимают память.
* Сообщение записывается в UDS синхронно. Это означает, что если по каким-то причинам агент долго обрабатывает пакет или не отвечает, то все сегменты на этом хосте в этот момент ждут завершения отправки, что замедляет базу в целом.
### Требования к системе
Перед началом проектирования системы важно составить список требований, которым она должна соответствовать. Иначе можно разработать то, что просто уйдет в стол. Но не всегда требования означают ограничения, некоторые из них можно расценивать как послабления, которые, в свою очередь, дают больше свободы при проектировании и реализации. Рассмотрим пример одного из таких свойств.
В нашем случае система мониторинга должна быть:
* отказоустойчивой;
* доступной;
* высокопроизводительной;
* как можно менее сложной;
* просто обновляемой;
* предоставлять метрики в режиме, максимально приближенном к реальному времени.
Рассмотрю последние три пункта подробнее.
Сложность системы означает многое: это и общее количество компонентов (как своих, так и сторонних), и взаимодействие между ними, и трудоёмкость в поддержке, и практически неизбежные изменения в инфраструктурных требованиях к системе.
Обновление системы также должно быть продумано с точки зрения миграции данных, времени простоя, возможности возврата к предыдущей версии и пр.
Так как ADCC является системой мониторинга, то естественно, что к ней предъявляется и требование по времени отклика. В нашем случае оно может быть мягким. Задержка отображения метрик на клиенте в размере 1 секунды для пользователя не критична, поскольку очень быстрые запросы отслеживать в online не имеет смысла (их можно посмотреть в истории запросов), а для продолжительных запросов такая задержка незначительна. И это послабление дает гораздо больше свободы при реализации.
Что мы сделали
--------------
В итоге мы составили концепт новой архитектуры ADCC:
 Компоненты новой архитектуры:
* **JNI library *—*** нативная библиотека для работы с сокетами.
* **Extensions** — компонент с расширениями. Не менялся с предыдущей версии.
* **Agent** — новое приложение, реализованное на Java, которое принимает и фильтрует метрики от Extensions, балансирует нагрузку при отправке с помощью распределения метрик между Backend Server’ами по уникальному идентификатору запроса. Java был выбран по нескольким причинам:
+ Backend server реализован на Java, а Agent разрабатывается той же командой. Поэтому не нужно менять контекст при разработке, что, помимо прочего, упрощает реализацию взаимодействия Agent и Backend server.
+ JRE уже доступна на хостах Arenadata DB, поскольку она обеспечивает работу средства импорта/экспорта данных из внешних систем — PXF.
* **Backend Server** — новый горизонтально масштабируемый сервис обработки и агрегации метрик, также написан на Java. Он же записывает информацию по запросам в базу данных и отправляет обновления на Web Server.
* **Service Registry —** каталог зарегистрированных в системе сервисов ADCC.
* **Web Server —** предыдущая версия Web Server, из которой убрана функциональность по обработке метрик и записи их в базу данных.
* **Web UI *—*** клиентское web-приложение не изменилось с предыдущей версии.
* **Database** — компонент базы данных остался без изменений с предыдущей версии.
В целом последовательность получения и обработки метрик не изменилась, но если вдаваться в детали, то отличительных особенностей довольно много, ниже мы рассмотрим часть из них.
1. Agent обрабатывает принятые пакеты асинхронно за счет внутренней очереди, куда складываются все принятые пакеты. Сообщения из очереди обрабатываются пулом потоков, что также увеличивает производительность агента.
2. Работа с сокетами реализована за счет native-библиотеки и обращение к ней через JNI. Это обусловлено сохранением протокола взаимодействия между Extensions и Agent. Как говорилось выше, он включает в себя также самописный протокол-надстройку над UDP. Экспериментально мы выяснили, что вызовы через JNI справляются с этой задачей примерно на 20 % лучше, чем аналогичная реализация на Java, поскольку до Java 16 нельзя было [работать с датаграммами](https://openjdk.java.net/jeps/380) [напрямую](https://openjdk.java.net/jeps/380).
3. В Agent добавили фильтрацию метрик, которые не обрабатываются системой, что снижает нагрузку на сеть и компоненты.
4. Обмен сообщениями между Agent и Backend server заменили на gRPC, что позволило не только переиспользовать protocol buffer, но и применить мультиплексирование, дополнительные возможности HTTP 2, а также асинхронную отправку данных «из коробки».
5. На стороне Agent реализовали балансировку нагрузки между несколькими экземплярами Backend Server при помощи шардирования метрик по уникальному идентификатору запроса. При этом сохраняется консистентность данных при добавлении новых экземпляров Backend Server. Эта функциональность еще и помогает избавиться от неявного ограничения пропускной способности из-за мультиплексирования TCP-соединения. При наличии нескольких Backend Server’ов мы создаем по одному TCP-соединению на каждый экземпляр, что увеличивает общую пропускную способность.
6. Обработка метрик в Backend Server стала пакетной. Полученное сообщение складывается во внутреннюю очередь (в соответствии с типом сообщения). Отдельный фоновый процесс батчами вычитывает из всех очередей сообщения и свёртывает метрики: формирует одно insert/update-выражение из метрик, относящихся к одному запросу. Далее полученные метрики отправляются асинхронно на Web Server и записываются в базу данных с использованием JDBC batch processing.
Результаты
----------
Нам удалось реализовать систему, которая не только решает проблемы производительности предыдущей версии, но и готова к обработке гораздо больших объемов данных. Первая версия не справлялась с нагрузкой, если включить `GUC gp_enable_gpperfmon`, который позволяет периодически собирать информацию о прогрессе выполнения запроса (без этой опции состояние запроса приходит только на момент начала его выполнения и по его завершении). В новой версии даже при минимальной конфигурации системы включение `gp_enable_gpperfmon` не приводит к проблемам, что позволило при помощи графического представления отслеживать состояние выполнения узлов запроса в режиме near-online.
Планы
-----
Мы взялись за переписывание UI (с сохранением существующей функциональности), чтобы изменить протокол обмена данными между ним и Backend Server. Основная идея заключается в том, чтобы отправлять на UI только те данные, которые необходимы. Также в планах обработка получаемых от Arenadata DB метрик в отдельном потоке, замена канала обмена между Extensions и Agent на POSIX-очередь сообщений, сжатие больших сообщений и ряд других изменений.
В дальнейшей перспективе будем добавлять новые типы метрик для обработки, повысим детализацию по уже обрабатываемым метрикам, улучшим UI и UX, а также разделим хранилища метрик на холодное и горячее.
> Хочу поблагодарить за помощь в подготовке этого материала моего коллегу, разработчика Greenplum, Ивана Лескина ([@leskin-in](https://habr.com/ru/users/leskin-in/)). Иван очень хорошо знает устройство и тонкости работы Greenplum. Он составил детальное описание работы расширений и провел тщательное рецензирование данной статьи.
>
> | https://habr.com/ru/post/564552/ | null | ru | null |
# Выращивание искусственного интеллекта на примере простой игры
В этой статье я поделюсь опытом выращивания простейшего искусственного интеллекта (ИИ) с использованием генетического алгоритма, а также расскажу про минимальный набор команд, необходимый для формирования любого поведения.
Результатом работы стало то, что ИИ, не зная правил, самостоятельно освоил игру крестики-нолики и нашел слабости ботов, которые играли против него. Но начал я с еще более простой задачи.
Набор команд
------------
Все началось с подготовки набора команд, которым мог располагать ИИ. Языки высокого уровня содержат сотни различных операторов. Чтобы выделить необходимый минимум, я решил обратиться к языку Ассемблер. Однако, оказалось, что и он содержит множество команд.
Мне требовалось, чтобы ИИ мог читать и выводить данные, работать с памятью, выполнять вычисления и логические операции, делать переходы и циклы. Я наткнулся на язык Brainfuck, который содержит всего 8 команд и может выполнять любые вычисления (т.е. полон по Тьюрингу). В принципе, он подходит для генетического программирования, но я пошел дальше.
Я задался вопросом: какое минимальное количество команд необходимо для реализации любого алгоритма? Как оказалось — одна!
Процессор URISC содержит всего одну команду: вычесть и пропустить следующую инструкцию, если вычитаемое было больше уменьшаемого. Этого достаточно для построения любого алгоритма.
Олег Мазонка пошел еще дальше, он разработал команду [BitBitJump](http://www.opennet.ru/docs/RUS/bbjr/bbjr.utf8) и доказал, что она полна по Тьюрингу. Команда содержит три адреса, копирует один бит из первого по второму адресу памяти и передает управление на третий адрес.
Позаимствовав идеи Олега, для упрощения работы, я разработал команду SumIfJump. Команда содержит четыре операнда: A, B, C, D и выполняет следующее: к ячейке по адресу B прибавляет данные из ячейки по адресу A, если значение получилось больше заданного\*, то переходит по адресу C, иначе переходит по адресу D.
**Примечание**\*В данном случае использовалось 128 — половина от длинны генома.
Когда операнд A обращается к ячейке памяти N0, происходит ввод данных, а когда к ячейке N1, то вывод.
Ниже представлен код SumIfJump на FreePascal (бесплатный аналог Delphi).
```
procedure RunProg(s: TData);
var
a, b, c, d: TData;
begin
Inc(NStep);
if NStep > MaxStep then
begin
ProgResult := 'MaxStep';
Exit;
end;
a := s;
b := s + 1;
c := s + 2;
d := s + 3;
a := Prog[a];
b := Prog[b];
c := Prog[c];
d := Prog[d];
if a = 0 then
begin
ProgResult := 'Input';
Exit;
end;
if a = 1 then
begin
ProgResult := 'Output';
Exit;
end;
Prog[b] := Prog[b] + Prog[a];
if Prog[b] < ProgLength div 2 then
RunProg(c)
else
RunProg(d);
end;
```
SumIfJump реализует самомодифицируемый код. Может выполнять любые алгоритмы, доступные на обычном языке программирования. Код легко изменяется и выдерживает любые манипуляции.
Простая задача
--------------
Итак, у нашего ИИ всего одна команда. Пока крестики-нолики для него очень сложная игра, и я начал с более простой.
Бот выдает случайное число, а ИИ должен считать данные и дать ответ. Если число больше среднего (от диапазона случайных чисел), ИИ должен выдать число меньше среднего и наоборот.
Геном нашего ИИ состоит из 256 ячеек со значениями от 0 до 255. Каждое значение — это и память, и код, и адрес. Количество шагов выполнения кода ограничено 256. Операнды читаются друг за другом.
Первоначально геном формируется набором случайных чисел, поэтому ИИ не знает, во что ему нужно играть. Более того, он не знает, что нужно последовательно вводить и выводить данные, отвечая боту.
Популяция и отбор
-----------------
Первая популяция состоит из 256 ИИ, которые начинают играть с ботом. Если ИИ совершает правильные действия, например, запросил данные на ввод, а потом что-то вывел, то ИИ получает очки. Чем больше правильных действий, тем больше очков.
16 ИИ, которые набрали больше всего очков, дают по 15 потомков и продолжают участвовать в игре. Потомок — это мутант. Мутация происходит заменой у копии родителя одной случайной ячейки на случайное значение.
Если в первой популяции ни один ИИ не набрал очков, формируется следующая популяция. И так до тех пор, пока какой-нибудь из ИИ не начнет совершать правильные действия и давать «правильное» потомство.
Эволюция
--------
| N | Вехи |
| --- | --- |
| 1 | ИИ ничего не делает. Программа совершает 256 шагов и завершается. |
| 2 | Начал запрашивать данные. |
| 3 | Начал запрашивать данные и что-то выводить. Последовательность запросов и ответов хаотичная. |
| 4 | Ввод и вывод данных происходит последовательно, иногда возникают ошибки. В половине случаев ИИ дает правильный ответ. |
| 5 | Регулярно дает правильные ответы, но иногда возникают ошибки. |
| 6 | Дал правильный ответ в 30 тыс. итерациях. Отбор закочен. |
Между значимыми событиями проходили тысячи смен поколений. Программа была запущена в несколько потоков на Core i7. Вычисления заняли около 15 минут.
Интересные моменты
------------------
1. Когда ИИ «лидер» совершал случайную ошибку и не набирал достаточное количество очков, популяция начинала деградировать, т.к. потомство формировалось из «второстепенных» родителей.
2. Бывало так, что в потоке с аутсайдерами, которые топтались на месте, происходила удачная мутация, обеспечивающая взрывной рост набираемых очков. После чего этот поток становился лидером.
3. Иногда в течение долгого времени не происходило никаких удачных мутаций, и даже 500 тыс. поколений не хватало, чтобы завершить отбор.
Заключение
----------
В заключение я проделал то же с игрой крестики-нолики. Размер генома использовал тот, что и в первом случае. Количество шагов было увеличено до 1024, а размер популяции до 64 (для более быстрого расчета). Расчет занял несколько больше времени. Все происходило примерно по тому же сценарию.
Сначала ИИ играл против «рандомайзера». Я так назвал бота, который ходит случайным образом. Довольно быстро ИИ начал его обыгрывать, заполняя какую-либо строчку. Далее я усложнил задачу, добавив рандомайзеру немного разума: занимать линию, если есть возможность, либо защищаться. Однако, и в этом случае ИИ нашел слабости бота и стал обыгрывать его. Пожалуй, рассказ об этом — это тема для отдельной статьи.
Сын просил написать программу, чтоб ИИ играли между собой, а не с ботом. Были идеи сделать то же для игры шашки или го, однако, для этого у меня уже не хватило времени.
Единственный метод, который я применял для получения новых особей, — это мутация. Можно также использовать кроссовер и инверсию. Возможно, эти методы ускорят получение требуемого результата.
В конце родилась идея: дать ИИ возможность управлять всеми процессами на ПК и бороться за ресурсы компьютера. Подключить ПК к интернету, а в качестве вычислительных мощностей использовать пул старых биткойн ферм…
Как сказал, проводя аналогичный эксперимент, блогер [Михаил Царьков](https://www.google.ru/search?q=foo52ru):
> Может, они мир захватят, а вдруг?
Ссылки
------
1. [Генетические алгоритмы](https://prog-cpp.ru/genetic/)
2. [Копирование Бита — Простейшая Вычислительная Машина / Олег Мазонка](http://www.opennet.ru/docs/RUS/bbjr/bbjr.utf8)
3. [URISC — Википедия](https://ru.wikipedia.org/wiki/URISC)
4. [Полнота по Тьюрингу — Википедия](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%BD%D0%BE%D1%82%D0%B0_%D0%BF%D0%BE_%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D1%83) | https://habr.com/ru/post/406673/ | null | ru | null |
# Ещё один формат хранения архивов: dar
Введение
--------
Есть известная поговорка, что системные администраторы делятся на три типа: тех, кто не делает бэкапы; тех, кто *уже* делает бэкапы и тех, кто делает и проверяет, что бэкапы рабочие.
Однако этого недостаточно, и сейчас для пользователя системы бэкапов важен такой параметр как скорость, причём не только скорость самого бэкапа, то есть архивирования файлов, но и восстановления.
Согласитесь, ведь глупо считывать целиком весь архив размером в 50-100-1000 гигабайт, чтобы извлечь один файл.
А если у вас эти архивы инкрементальные, то чтобы восстановить один файл за нужную дату, нужно будет последовательно читать все архивы по порядку. И всё становится намного хуже, если файл архива расположен на удалённом сервере.
И именно этим вы будете заниматься, если будете использовать формат архива TAR. Ведь это промышленный стандарт для архивов, и он используется во многих утилитах для бэкапа.
И причина такого поведения очень проста — отсутствие индексов, по которым можно вытащить один файл из архива.
У TAR вообще много недостатков, многие из них — фатальные. Я приведу небольшой список основных недостатков, на которые натолкнулся за время исследования:
* Отсутствие индекса, и как следствие — невозможность вытащить один файл, не считывая весь архив.
* Зоопарк форматов: GNU tar разных версий, BSD tar тоже разных версий, которые подразумевают иногда несовместимость архивов между собой.
* Отсутствие встроенного шифрования.
* Невозможность селективного сжатия (зачем нам, например, сжимать jpeg?).
* Совершенно невнятные ошибки при архивации и при восстановлении (типичным сообщением об ошибке является «Unexpected EOF of archive», которое может обозначать что угодно).
* Он может просто не сделать архив, например, потому что часть файлов была удалена во время архивации, и tar никак эту ситуацию не обрабатывает.
И это только то, что я вспомнил с ходу.
Я провёл достаточно обширное исследование архиваторов (zip, rar, 7zip) и даже всяких монструозных систем для бэкапов: опенсорсных (ну или условно опенсорсные) типа bacula, и проприетарных.
И нашёл формат архива, который меня и компанию более или менее устроил по всем параметрам и подходил к моей задаче.
Я предлагаю вам обратить внимание на архиватор [dar](http://dar.linux.free.fr/) и коротко расскажу о его преимуществах и недостатках (они есть, но их немного, и с ними можно жить), а потом перейду к практическим примерам.
### Достоинства
* У файла архива есть индекс, и даже больше — сам индекс можно разместить отдельно и забэкапить, что позволит восстановить архив, если у него был повреждён индекс.
* Не только привычные дифференциальный и инкрементальный бэкапы, но и декрементальный.
* Шифрование (blowfish, aes, twofish, serpent, camelia).
* Можно сжимать файлы с определёнными расширениями.
* Можно не сжимать файлы с определёнными расширениями.
* Можно гибко управлять процессом архивации и разархивации (как реагировать на удаление файлов, на изменение, перемещение и пр.).
* Есть поставляемый с dar менеджер архивов, он позволяет не восстанавливать все архивы подряд при поисках файла, автоматически выбирая только нужные.
Это только основные его преимущества, вообще dar очень богат на фичи и об этом лучше всего говорит цитата из man: «...But due to the lack of available unused letter for command line options...».
Проект достаточно активно развивается и хорошо поддерживается разработчиком. На свои вопросы я получал ответ в течении пары дней, причём ответы всегда очень содержательны. Я знаю только один проект с таким же уровнем поддержки — [libguestfs](http://libguestfs.org/), к слову, я про него [уже писал](http://habrahabr.ru/post/121218/).
### Недостатки
* Нереальное количество опций, а если всерьёз закапываться в то, как реагировать на различные изменения файлов при архивации/разархивации — свихнуться можно.
* Совершенно неочевидный процесс архивации/восстановления через пайп (например, по ssh).
* В определённых ситуациях dar может потребовать реакции пользователя (это решается через добавление аргументов к команде, но, как правило, эта интерактивность проявляется очень неожиданно, особенно пока вы пишете свои первые скрипты с dar).
Не то, чтобы это недостаток, но dar очень многословен. Если tar после выполнения операции напишет одну строчку, то dar пишет очень много и очень подробно. И конечно, его можно заткнуть (ещё никто не избегал `>/dev/null 2>&1`).
Практикум
---------
Я готов поспорить, что часть аудитории уже побежала устанавливать dar в своих любимых дистрибутивах и читать man'ы самостоятельно. Для тех же, кто остался, я расскажу как им пользоваться. А когда энтузиасты вернутся, я покажу, как пользоваться этой замечательной утилитой, и расскажу о некоторых базовых понятиях, которые вы встретите на страницах `man dar`.
### Архивирование
Первый пример, самый простой:
`dar -R $HOME -c /mnt/backup/archive`
Архивирует директорию /home.
Давайте исключим пару директорий (~/movies, ~/downloads):
`dar -R $HOME -c /mnt/backup/archive -P movies -P downloads`
Я думаю, все уже заметили, что название архива никак не упоминает расширение файла .dar. А ещё в имени файла откуда-то взялась цифра 1. Это всё потому, что dar изначально предназначается для бэкапа на сменные носители (CD, DVD или, например, ленточные накопители), поэтому он архивирует в *слайсы*, а циферка 1 возникает потому, что этот слайс *первый*. А поскольку мы не указывали ключик `-s 100M` — и единственный. У dar есть также ключи для запуска скриптов, при выполнении определённых операций (такие ключи есть и у tar). Например, когда слайс записан, можно выполнить скрипт и поменять носитель, а потом ещё раз и так далее.
В общем, разбитием архива на несколько частей никого не удивишь.
По умолчанию dar архивирует без сжатия, и чтобы включить сжатие нужно передать ему ключик `-z algo:level`. Поддерживаются gzip, bzip2, lzo. И на выходе мы получим такой же файл .N.dar, без добавления всяких .gz и прочих. Архиватор сам знает что у него внутри.
Перейдём к следующей вкусности — исключениям для сжатия при архивации:
`dar -R $HOME -c /mnt/backup/archive -Y "*.txt" "*.fb2" -Z "*.mp4"`
Ключ `-Y` указывает для каких файлов нужно включать компресию, а `-Z` — для каких не нужно. Причём по умолчанию исключение имеет более высокий приоритет (но это поведение можно поменять при необходимости).
А теперь приступим к дифференциальному, инкрементальному и самому вкусному — декрементальному бэкапу.
Если кто-нибудь не знает, что это означает — нестрашно, я расскажу:
* Дифференциальный: сначала создаётся полная копия, а каждый последующий день сохраняется только разница между этой копией и текущим состоянием файлов.
* Инкрементальный: создаётся полная копия, на следующий день сохраняется разница между полной и текущим состоянием, на третий — разница между вторым днём и третьим.
* Декрементальный: каждый день сохраняется полная копия и сохраняется разница между текущим состоянием и вчерашним.
При этом вам никто не мешает реализовывать одновременно и инкрементальный, и декрементальный бэкап. Так что за две недели бэкап может выглядеть так (сверху дни недели, снизу тип бэкапов d- — декрементальный, +i — инкрементальный):
`M T W T F S S M T W T F S`
`d- d- d- d- d- d- f +i +i +i +i +i +i`
Что позволит обойтись одной полной копией, сэкономив существенное количество места.
Следует также знать, что единственным, что вам понадобится для того чтобы сделать инкрементальный архив — индекс. В терминах dar индекс называется каталогом, а сохранение индекса в файл — изоляцией каталога. Также я далее буду использовать только термины инкрементальный/декрементальный, поскольку дифференциальный архив — частный случай инкрементального
Итак, давайте создадим инкрементальный архив:
`dar -R $HOME -c /mnt/backup/archive_monday -A /mnt/backup/archive`
А теперь сделаем ещё один:
`dar -R $HOME -c /mnt/backup/archive_tuesday -A /mnt/backup/archive_monday`
Идею поняли? Отлично, едем дальше. А сейчас давайте сохраним индекс отдельно (обратите внимание, мы его не вырежем из архива, а просто скопируем, это как с бэкапом mbr. Вы ведь делаете бэкап своего загрузчика?), чтобы потом не ворочать многогигабайтным бэкапом только ради создания инкрементного архива. Мы делаем сейчас «изоляцию на лету», но каталог можно сохранить в любое удобное время, взяв его из готового архива.
`dar -R $HOME -c /mnt/backup/archive_wednesday -A /mnt/backup/archive_tuesday -@ /mnt/backup/CAT_archive_wednesday`
А теперь давайте сделаем бэкап ещё разок, используя только индекс CAT*archive*wednesday:
`dar -R $HOME -c /mnt/backup/archive_thursday -A /mnt/backup/CAT_archive_wednesday -@ /mnt/backup/CAT_archive_thursday`
Отлично, мы разобрались со знакомым многим инкрементальным бэкапом, но что такой за зверь декрементальный бэкап?
Для начала нам нужен один вчерашний полный архив из которого мы будем делать декрементальный, и сегодняшний полный.
`dar -R $HOME -c /mnt/backup/archive_sunday`
`dar -R $HOME -+ /mnt/backup/archive_saturday_decremental -A /mnt/backup/archive_saturday -@ /mnt/backup/archive_sunday -ad`
Вообще, тут немного всё запутано (привыкайте), поскольку `-+` по документации создан для *объединения* двух архивов, а `-@`, как мы уже говорили, служит для изоляции каталога «на лету», и ключ `-ad` меняет поведение этих ключей, чтобы реализовать декремент. В некотором смысле это логично. Наверное.
Ну вот мы и подобрались к моменту истины — восстановлению данных. Ведь все понимают, что сделанный бэкап, который нельзя восстановить, равносилен несделанному бэкапу?
Перед восстановлением было бы неплохо проверить архив:
`dar -t /mnt/backup/archive_sunday`
Если dar не вернул код ошибки (в конце man'а перечислены все возможные коды выхода, которые dar может вернуть), то можно восстанавливать:
`mkdir sunday`
`dar -x /mnt/backup/archive_sunday -R sunday`
### Операции на удалённых машинах
#### Восстановление файлов
Я вскользь уже упоминал, что восстановление файлов с удалённых машин, через пайп (например, по ssh) является нетривиальной задачей.
Попробую подробно рассказать как это работает.
Все сложности связаны с тем, что для восстановления одного файла dar нужно читать индекс. Если же использовать его аналогично tar, в режиме потокового чтения (ключ --sequential-read), то таких проблем не возникает.
Для решения проблемы с чтением индекса создано две версии dar:
* Основная: dar, которая говорит, что нужно восстановить.
* Вспомогательная: dar\_slave, которая принимает команду и передаёт dar восстановленные данные, которые dar потом записывает на диск.
Поэтому схема работы (для восстановления) выглядит так:
`(2) --> dar --> (1) --> dar_slave archive --> (2)`
1. dar через пайп говорит dar\_slave: «Хочу восстановить файл А».
2. dar\_slave считывает индекс файла archive, узнаёт, по какому смещению находится искомый файл, и передаёт его на stdout, который читает dar и пишет полученный файл на диск.
Сложность заключается в том, чтобы осуществить передачу файла от dar\_slave в dar. Для такой «кольцевой» передачи данных нам придётся соорудить небольшой костыль при помощи mkfifo:
``mkfifo /tmp/fifo<.code>
dar -x -i /tmp/fifo -R sunday | ssh user@host dar_slave sunday > /tmp/fifo`
`rm /tmp/fifo`
Этих проблем можно избежать, если монтировать удалённую директорию, например, по NFS.
#### Упаковка файлов
При упаковке файлов тоже есть небольшая хитрость: нужно обязательно сохранять файл индекса архива на локальной машине, чтобы на его основе можно было строить инкрементальные архивы:
`dar -R $HOME -c - -A /mnt/backup/CAT_archive_wednesday -@ /mnt/backup/CAT_archive_thursday | ssh user@host 'cat > archive_thursday'`
Разные приятности
-----------------
Также в комплекте с dar идёт утилита под названием dar_manager, которая является обёрткой на стероидах над dar. По сути, это приложение, которое, оперируя полученными из архивов индексами, позволяет упростить жизнь при восстановлении данных (например, не придётся копаться в сотне архивов, чтобы найти, откуда можно будет восстановить нужный файл).
Я ей не особо пользовался, только запускал пару раз, чтобы понять для чего и как она используется.
Единственное, что я, возможно, не советовал бы: использовать её в качестве production-решения, поскольку я частенько в списках рассылки встречал сообщения о том, что файл в котором она хранит индексы бьётся, что, впрочем, никак не влияет на сохранность самих данных.
Также в комплекте с dar идёт dar_static: статически скомпилированый бинарник, который никогда не будет лишним положить рядом с архивами.
Важное замечание
----------------
Поскольку утилита достаточно активно разрабатывается, у неё есть периодически возникающие проблемы (которые оперативно решаются в списке рассылки), и в связи с этим в дистрибутивах почти всегда присутствует неактуальная версия dar. Например в Ubuntu 12.04 используется, если не ошибаюсь dar версии 2.4.2, которая не может создать/восстановить архив в некоторых специфичных условиях. С dar версии 2.4.12 лично у меня никаких проблем нет.
Также стоит отметить, что архивы, сделанные версией 2.4, скорее всего не будут распаковываться dar версии 2.3 ввиду изменения формата архива.` | https://habr.com/ru/post/215449/ | null | ru | null |
# История небольшого исследования легаси-кода
Хорошо, когда в команде есть кто-то более опытный, кто покажет что и как надо делать, какие грабли и за каким углом подстерегают, и где скачать лучшие чертежи велосипедов за 2007 год на DVD. Эта история о том, как желаемое было выдано за действительное, что получилось в результате, и как был преодолен кризис.
Это случилось в ту пору, когда я, имея весьма, как мне казалось, посредственный опыт в разработке, искал место, где можно из недоджуниора эволюционировать (или мутировать) хотя бы в уверенного джуниора. Неисповедимыми путями Господними такое место нашлось, в довесок к месту прилагался проект, и “олдскульный” программер, который за свою карьеру систем написал больше чем девок перепортил. “Отлично! Проект, а следовательно деньги на ЗП есть, наставник прилагается, живем!” — подумал я, но затем, как в описании к типичному хоррору, герои в темной тьме столкнулись с ужасным ужасом…
Обо всем по порядку:
#### 1. Размер имеет значение
Разработку начали на самописном кем-то когда-то php-движке, для хранения данных использовали (тут вы можете подумать MySQL\PostgreSQL\SQLite\MongoDB\Что-то-там-еще-но-обязательно-с-суффуиксом DB-иначе-пацаны-не-поймут, а вот и не угадали) api-шлюз.
“Нафига, используя php, вы приделываете к нему еще какой-то api-шлюз, и храните на нем данные? Не проще ли работать с api напрямую из js-кода? Или использовать СУБД+PHP?” — спросит видавший виды читатель. И будет прав. Но в ту пору я, не видавший еще видов, так не думал, ну кто ж его знает, крутые пацаны так наверное делают, и “олдскульным” программерам виднее.
Как мне было далее разъяснено:
1. Шлюз = безопасность, никто не войдет и не выйдет просто так
2. Шлюз = защищенное хранение данных, просто так не залезешь, +бекапы
3. Шлюз = скорость, работает быстро и без сбоев, проверено временем
4. Авторитетная точка зрения “олдскульных” программистов гласит — ваш php дырявый весь, любое веб-приложение взломано по умолчанию, поэтому нечего данные хранить рядом с ним
Характерной особенностью api-шлюза являлось то, что json-данные передавались в get-запросе. Да-да, те самые милые сердцу json-объекты, подвергались url-кодированию, и клались в query string. И все бы хорошо, как вдруг однажды… длины get-запроса перестало хватать. Тупо не влезал туда url-кодированный json, каналья! “Олдскульный” программер, почесав затылок, спросил:
“Шо будем делать? Подрос наш json, а мы и не заметили…”.
“Ну, эээ, может тогда в post их будем передавать?” — предложил я, так вроде правильней будет.
“Ок, передавайте в post”.
Это был атас номер раз.
#### 2. Тайм-энд-бекап-менеджмент
Чтобы прикрутить новую функциональность в проект, надо было реализовать
соответствующие CRUD-запросы на шлюзе, чем собственно и занимался наш “олдскульный” товарищ. Проблема заключалась в том, что занимался он этим раз в 3 дня, выдавая — “Готово, проверяй”. Проверки временами показывали что работало не все, например получение списка — ок, добавление нового элемента — не ок. На исправление и доработку уходило еще какое-то время, после чего можно было выпускать функционал в массовый доступ. Предложение самому заняться реализацией запросов на шлюзе, потому что это как минимум быстрее, было отклонено, потому что “там сложно, ты не разберешься”. Итогом такого подхода стало замыкание работы “на себя”. Если, например, нужно было что-то массово исправить в БД, то, выбирая между 3-х дневным ожиданием и реализацией исправлений самому через запросы — я выбирал 2-й вариант. Заказчики ждать особо не любили, новые вводные прилетали стабильно. Одну из таких вводных, а именно массовое проставление пользователям некоего признака мне и поручили реализовать, времени на все про все — час, начальство ждало красивый отчет. Здесь нас поджидает атас номер два-с.
Дело в том, что формат json-данных, передаваемые в запросах, предполагал лишь несколько обязательных полей, все остальные были произвольными, четкой и окончательной структуры не существовало. Например, для добавления пользователя я передавал json вида:
```
POST /api/users
{
"email":"ivanov@mail.ru",
"password":"myEmailIsVeryBig",
"name_last":"Иванов",
"name_first":"Иван",
"name_middle":"Иваныч",
"birth":"01.01.1961",
//а вот тут следует вольноопределяемая часть, что считаем нужным - то и отдаем
"living_at":"ул.Сусаниа, д.3 к.4 кв.24",
"phone_num":"+70000000000"
}
```
Та необязательная часть, которую передавали в запросах добавления\обновления — сохранялась и отдавалась в полном составе (о том как это было реализовано — расскажу ниже). Суть да дело, время на месте не стоит, надо бы и задачу решить — обновить пользователей, проставить им метки. Но не гонять же каждый раз всю структуру? Надо проверить! Протестировал на себе — передал в запросе на обновление только одно поле, проверил, поле появилось, остальные данные на месте. Дело за малым — зациклить и обновить остальных.
Скрипт тихонько пыхтел, принимая и отдавая данные, и вроде бы все шло хорошо… как вдруг — звонок. “Мы не видим ФИО пользователей в системе!” — сообщают с того конца провода. “Да ну нафиг! Нормально ж отрабатывало!” — по спине пробежал неприятный холодок. Дальнейшее расследование показало, что действительно, в строке ФИО значилось “”, хотя все остальные данные были на месте. Что делать в такой ситуации? Разворачивать бекап!
“Товарищ “олдскульный” программер, уи хэв э проблем хир! Нужно бекап! Когда последний актуальный сделан?” — спрашиваю.
“Э-э-э… Сейчас посмотрю…. Не, бакапа нету”.
Спасло ситуацию то, что парой часов ранее я доработал и протестировал модуль с отчетами, у меня была csv-шка со всеми необходимыми данными, в течение еще одного часа порядок был восстановлен.
Отсутствие внятной документации, описания алгоритмов работы, входных проверок на валидность, и что самое главное — бекапов БД — атас номер два-с.
С тех пор бекапы стали сниматься каждый день.
#### 3. Deep striking
Шатко-валко, но работа двигалась, проблемы решались, какие-то быстрее, какие-то медленнее, как вдруг… заказчики спохватились, что система лежит на не пойми чьих серверах, и за такое отношение к ПДн и организации мероприятий по ЗИ в ИСПДн их по головке не погладят. Надо переносить сервера к себе.
Почему изначально система не была передана? У руководства была одна страсть — централизация. Руководство мечтало о системе которая будет делать всё! Нужно тебе детёнка в школу пристроить? Заходишь в систему, в специальный кабинет, там подаешь заявление. Нужно тебе, скажем пиццу заказать — заходишь в систему, в другой специальный кабинет, подаешь заявление на пиццу. Может тебе общения с прекрасными дамами\кавалерами захотелось? К вашим услугам третий специальный кабинет — там тоже заявление подаешь.И так до бесконечности.
Преимущества — один логин и пароль на всё, данные надежно и безопасно хранятся на шлюзе. Даже бекапы есть. И, заметьте, никто у нас эту систему не отнимет! А даже если отнимет — что дальше? Все равно не разберутся в системе защиты от “олдскульных” программистов — там сложно всё.
VDS с системой выгрузили, отнесли к заказчикам, они ее развернули, все танцует и поет, красота!
И тут меня накрыло волной любопытства и некоторых подозрений.
Если наше веб-приложение дырявое, то где же данные? Неужели остались на других серверах? А если систему решат закрыть извне — то все рухнет?
Простая проверка показала, что данные, как и сами обработчики шлюза стояли на этом же сервере. И, нет, их не перенесли туда по причине передачи сервера, они там были всегда.
Теперь у меня в распоряжении была та самая секретная “олдскульная” разработка, которую я и принялся исследовать. Конечно, крутого реверс-инжинирнга в стиле статей журнала “Хакер”, с ollydbg, смещениями, и прочими крутыми штуками не получилось, поэтому делюсь тем, что есть.
Собственно разработка была вполнена на python, остались только .pyc-файлы, которые легко декомпилировались обратно в читаемый код. Скажу честно, много времени, целых 25 минут, ушло на то, чтобы разобраться как это работает.
Итак, сложная система, разработанная “олдскульным” программером, в которой мало кто может разобраться, состоит из:
1. Скрипта, обрабатываемого апачем, который собственно и получал запрос. Что делал данный скрипт? Открывал соединение на определенный порт localhost`а и передавал туда запрос со всеми его данными. Всё. Интересности идут дальше.
2. Серверной части, обрабатывавшей запросы от скрипта. Логика его действий была достаточно интересна. Во-первых, в коде не было никаких манипуляций с данными, и запросов в БД, вместо этого вызывались функции БД на PL\SQL. Вся логика, проверки, и прочее, все было заложено в функции БД. 50% скрипта составлял словарь содержащий имя запроса, сопоставленную ему функцию, и имена параметров функции, которые должны были соответствовать данным, переданным в строке get-запроса. JSON-данные, если они были нужны, передавали как отдельный параметр. Особенностью организации серверной части явилось резервирование подключения при аутентификации пользователя. Если логин и пароль обнаружены в БД — генерировался ИД сессии, а экземпляр открытого подключения складывался в словарь (и убивался по таймауту в 10 минут, чтобы не убивался — был специальный метод на продление жизни сессии), ключом являлся ИД сессии, который в БД напрямую не хранился. Как же именно связан ИД сессии с данными пользователя? Ведь есть запрос на получение данных, в который ИД пользователя не передается? Он работает, а значит что-то тут не так.
Очень сложная разработка давалась сознанию с трудом и не спешила раскрывать давно утерянные секреты мастеров прошлого.
Невероятным (Go to > Definition, спасибо PhpStorm за понимание PL\SQL), непостижимым разуму обывателя страданием Истинное Знание Утерянной Цивилизации Олдскульных Программистов было все же обретено. В общем — при подключении, в функции проверки данных аутентификации генерировалась временная таблица, в которой хранился ид пользователя.
Это было только началом, примерный список найденных серьезных уязвимостей:
* DDoS с помощью массовой аутентификации (подключения резезвировались, и, следовательно, упирались в лимит соединений СУБД, что с учетом имеющейся возможности продления времени жизни сессии позволяло полностью забить память подключениями, и работа новых пользователей в системе станет невозможна);
* отсутствие защиты от брутфорса (кол-во неудачных попыток входа не детектится, не хранится, не проверяется;
* отсутствие контроля действий с сущностями (например, список документов, запрошенный пользователем, выдавался с учетом организации, к которой пользователь привязан, при этом, если знать ИД документа, то можно успешно выполнить запрос на обновление\удаление документа, а список пользователей, хорошо хоть без паролей, которые, кстати, хранились в БД в открытом виде, без хеширования, мог получить вообще кто угодно).
И еще одна серьезная проблема — не формализованная схема хранения данных. Как и обещал ранее — рассказываю о хранении “любых полей” из JSON. Нет, они не хранились как строка в таблице. Они разбивались на key-value пары и хранились в отдельной таблице. Например, для пользователей было 2 таблицы — users, и users\_data (string key, string value) — где собственно и хранились данные. Итогом такого подхода стало увеличение времени при сложных выборках из БД.
Собственно этого хватило, чтобы принять и привести в жизнь решение о переводе системы на новое api, понятное, документированное, и поддерживаемое.
#### Мораль
Возможно, эта система являет собой “легаси”, а “олдскульный” программер, создавший ее — суть хранитель легаси.
Но тем не менее выводы следующие:
1. Если вам говорят “там сложно, ты не разберешься” — значит там полный атас
2. Если давят авторитетом — значит что-то нечисто
3. Доверяй, но проверяй — безопасность — не состояние, безопасность — процесс, притом непрерывный, посему лучше убедиться в соответствии декларируемых качеств действительности, чем потом узнать что все пользователи вдруг стали “Ивановыми Иванами Иванычами”, а бакапов нету. | https://habr.com/ru/post/450384/ | null | ru | null |
# Прощай, ViewState — 2, или В базу его!
Очередной раунд [нелёгкого](http://habrahabr.ru/blogs/net/60170/) [противостояния](http://habrahabr.ru/blogs/net/77187/) с ViewState. На этот раз попробуем сохранять его в БД SQL Server.
Немного повторим теорию. У нас есть класс [PageAdapter](http://msdn.microsoft.com/ru-ru/library/system.web.ui.adapters.pageadapter.aspx), использование которого может «адаптировать» aspx-страницу к определённому браузеру (в нашем случае — ко всем). С помощью этого адаптера можно переопределить функционал для загрузки и сохранения ViewState (с помощью метода [GetStatePersister](http://msdn.microsoft.com/ru-ru/library/system.web.ui.adapters.pageadapter.getstatepersister.aspx)).
Итак, порядок действий:
— создаем простенькую структуру в БД для хранения ViewState:
[](https://habrastorage.org/storage/habraeffect/4a/6a/4a6aeb6742d356efa6996e5df8f4d52a.png "Хабрэффект.ру")
Создаем также хранимые процедуры для получения, сохранения и очистки (устаревшего) ViewState;
— наследуем класс [PageStatePersister](http://msdn.microsoft.com/ru-ru/library/system.web.ui.pagestatepersister.aspx), в нём переопределяем методы Load и Save для реализации загрузки и сохранения ViewState соответственно:
> `namespace SqlStatePersister
>
> {
>
> public class SqlPageStatePersister : PageStatePersister
>
> {
>
> private Page \_page;
>
>
>
> public SqlPageStatePersister(Page page)
>
> : base(page)
>
> {
>
> \_page = page;
>
> }
>
>
>
> public override void Load()
>
> {
>
> // функционал загрузки и десериализации ViewState
>
> }
>
>
>
> public override void Save()
>
> {
>
> // функционал сериализации и сохранения ViewState
>
> }
>
>
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— наследуем класс PageAdapter, в нём переопределяем метод GetStatePersister, чтобы он возвращал экземпляр класса, определённого в первом шаге:
> `namespace SqlStatePersister
>
> {
>
> public class SqlPageAdapter : PageAdapter
>
> {
>
> public override PageStatePersister GetStatePersister()
>
> {
>
> return new SqlPageStatePersister(Page);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— с помощью .browser-файла «адаптируем» страницу:
> `<browsers>
>
> <browser refID="Default">
>
> <controlAdapters>
>
> <adapter controlType="System.Web.UI.Page" adapterType="SqlStatePersister.SqlPageAdapter" />
>
> controlAdapters>
>
> browser>
>
> browsers>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— по желанию добавляем плюшки, например, функционал gzip-сжатия перед сохранением в БД;
— создаём шедулер (например, SQL Server Job), который будет чистить таблицу от устаревших ViewState;
— PROFIT!
В **[примере](http://podelki.milovanov.info/aspnet/SqlStatePersisterDemo.zip)** (VS 2010 solution, .NET 4) используется БД [AdventureWorks](http://msftdbprodsamples.codeplex.com/), которая пришла на смену Northwind в качестве примера. Для работы приложения необходимо наличие в appSettings настройки ViewStateCompress, которая устанавливается в 1, если нужно gzip-сжатие, либо 0, если не нужно. В секции connectionStrings также нужна строка подключения к БД, в которой будет храниться ViewState (у меня в примере это отдельная БД, создаётся выполнением скрипта install.sql из солюшена).
Спасибо за внимание! Если потребуются более детальные комментарии к проекту, я к вашим услугам ;)
P.S. По мотивам [Store ViewState in the Database instead of Hidden Form Field](http://forums.asp.net/p/1293397/2504654.aspx) и [ViewState Compression](http://www.codeproject.com/KB/viewstate/ViewStateCompression.aspx). | https://habr.com/ru/post/109417/ | null | ru | null |
# Настольные игры для Windows Phone: разведка боем
 Мне повезло работать в Саровском Технопарке – секретном месте на границе Нижегородской области и Мордовского заповедника, где среди снегов и умных девушек, которых не соблазнишь iPhone’ом, создает свои нетленные произведения свободный художник, мастер малых форм и адепт iOS-программирования [PapaBubaDiop](http://geektimes.ru/users/papabubadiop/).
Здесь я получил благословление Папы Бубы на игрописание, а вместе с ним золотой запас исходных кодов игр «Чапаев» и «Башни» для iPhone. Всё это богатство было получено под обещание посеять доброе и вечное на полях Android и WP7.
Под хаброкатом привожу историю освоения небольшого, но активно удобряемого редмондским и эспоовским гигантами участка Windows Phone.
Игра
----
Шашечная игра Чапаев знакома многим с детства. Одно из виртуальных воплощений игры было представлено Папой Бубой полтора месяца назад. Сегодня раскрываю некоторые особенности реализации, задающие начальные условия для повторения Чапаева на платформе WP7:
* Игровой движок собственного производства, легко морфируемый под каждую новую игру;
* Использование стандартных элементов пользовательского интерфейса для построения сцены;
* Комбинирование анимации, выполняемой в игровом цикле (движение фишек после удара) со стандартной анимацией, предоставляемой SDK (для начального построения фишек, поворота доски или перехода хода).
Windows Phone
-------------
Поскольку мы сторонники эволюции, а не революции, для воплощения затеи были выбраны нативные средства программирования под Windows Phone, предлагаемые Microsoft. А задача переноса игры разделена на две части:
* Ретрансляция физического движка и модели игры в C#
* Реализация графического представления игры средствами Silverlight
Первый тонкий момент в реализации приложений для Windows Phone, с которым пришлось столкнуться, – это необходимость сохранять и восстанавливать состояние приложения и отдельных его страниц. Жизнь мобильного приложения коротка и даже невинная блокировка экрана приводит к закрытию страницы, а при некоторых условиях и вытеснению приложения из памяти. Разблокировка, соответственно, возвращает приложение и активную страницу в исходное состояние. В нашем случае состояние страницы есть состояние игры, включая расположение шашек и выполняемую анимацию.
Далее, не смотря на существенное упрощение жизни разработчика за счет предопределенного разрешения экрана для всех устройств Windows Phone, было решено различать виртуальный размер игрового поля и фактическое разрешение экрана. Как дань уважения Папе Бубе, система координат игровой модели приведена в соответствие экрану iPhone. В перспективе в этой же системе координат будет жить сетевая игра.
C#
--
Ретрансляция кода физической модели и модели игры, в основном, свелась к замене синтаксических конструкций вызова функций и конструирования объектов в Objective-C, не считая объединения декларации и определения методов класса в один файл исходного кода.
В результате, благодаря простоте используемых языковых конструкций и схожести языков C# и Java, полученный код моделей можно использовать на 98% при переносе приложения на Android. Один непереносимый процент – имена функций Windows Phone SDK, второй процент – свойства (properties) класса. И, если от платформно-зависимых имен можно избавиться, завернув их в переходники, то отказываться от использования свойств оказалось неразумно.
Properties существенно упрощает задачу сохранения и восстановления состояния игры, как того требует жизненный цикл приложения. В приведенном ниже фрагменте кода определяется элемент игры «шашка» и её свойства:
```
public class CheckerItem
{
public int color { get; set; }
public double x { get; set; }
public double y { get; set; }
}
```
В игре используется набор шашек:
```
public class GameObject
{
public CheckerItem[] checkers;
}
```
А так происходит сохранение состояния игры в изолированное хранилище приложения:
```
IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings;
settings["checkers"] = checkers;
```
И восстановление:
```
settings.TryGetValue("checkers", out checkers);
```
Silverlight
-----------
Для графического представления состояния игры и диалогов настройки выбор сделан в пользу Silverlight. Основной причиной применить неигровой фреймворк для игрового приложения стало желание вписать приложение в стиль Metro, насколько это возможно. Да и геймплей не предполагал серьёзных нагрузок на процессор, что впоследствии было подтверждено экспериментально – счетчикам производительности краснеть за выбор фреймворка не пришлось.
Однако не обошлось дело и без наступания на грабли.
Для реализации звуковых эффектов в игре использовался класс SoundEffect из набора средств XNA, что потребовало подключения XNA Framework и «ручного» проворачивания игрового цикла XNA. Но, самое печальное выяснилось уже после публикации: вместо основного меню телефона, приложение из магазина размещается в разделе Xbox Live. Надеюсь у пользователя достаточно желания и доброй воли его там найти после установки.
Еще одной неожиданностью стал глобальный для всего приложения обработчик касаний. Оказалось, однажды зарегистрированный обработчик события продолжит своё существование и после закрытия игровой страницы, будет радостно откликаться на тапы по странице настроек, например. Решение одно: минусовать обработчик событий при покидании страницы.
```
protected override void OnNavigatedTo(NavigationEventArgs args)
{
Touch.FrameReported += OnTouchFrameReported;
}
protected override void OnNavigatedFrom(NavigationEventArgs args)
{
Touch.FrameReported -= OnTouchFrameReported;
}
```
Вдобавок для моего случая потребовалось останавливать анимации при покидании страницы для синхронизации с состоянием игры, поскольку покидание страницы не всегда означает её разрушение, а возвращение возможно минуя конструктор страницы.
Публикация в Marketplace
------------------------
Цикл рассмотрения приложения в Windows Marketplace экспериментально определен как 4 рабочих дня, в выходные движения нет. Причем рассмотрение повторной заявки после исправления замечаний длится всё те же четыре дня.
С момента одобрения до начала работы прямой ссылки на приложение прошло еще не менее суток, и дополнительно часов 10-12 понадобилось для индексации внутри магазина. После чего приложение начало появляться в результатах поиска.
Таким образом, минимальное время, требуемое для публикации приложения, составляет 5 дней, при условии, что приложение идеально, а заявка отправляется в понедельник.
Процедура рассмотрения приложения дополнена забавной интригой – сообщение об отказе в публикации доставляется почтой, но причину отказа можно узнать только из pdf-отчета, который необходимо получить через портал AppHub. Система стройная, но на практике проделать это с помощью телефона, собираясь на работу в 7 утра, совсем не просто.
Результат труда можно оценить на видео (спасибо Толику из известной торговой сети за предоставленный Nokia 710):
Можно загадывать желание
------------------------
Когда делаешь что-либо первый раз в жизни, можно загадывать желание, и оно обязательно сбудется. Программист мыслит рационально и для повышения вероятности сбычи мечт делает одновременно три дела в первый раз в жизни: пишет игру для Windows Phone, впервые кодит на C#, и впервые публикует статью на Хабре. *Я загадал.* | https://habr.com/ru/post/139769/ | null | ru | null |
# Хорошо ли вы знаете linear-gradient?
*Работа над переводом [статьи](http://habrahabr.ru/company/paysto/blog/251933/) о проекте singlediv.com показала, что некоторые инструменты CSS имеют более широкое применение, чем я привыкла думать. Но для того чтобы суметь найти это применение, необходимо четко понимать особенности свойства. Ярким примером стал linear-gradient, который Линн Фишер виртуозно использовала в своих работах.*
Хотите сделать симпатичный градиентный фон на своем сайте? background-image: linear-gradient(red, blue); готово! Да, это немного скучно. Поэтому, если вы хотите чего-то большего, рекомендую вам эту [статью](https://css-tricks.com/css3-gradients/) с советами по css и [MDN](http://) страницу. Вы еще здесь? Тогда давайте рассмотрим некоторые моменты, как на самом деле работают линейные градиенты. Для начала, давайте вспомним синтаксис, который можно использовать в функции линейного градиента:
```
linear-gradient ([от <угла> | до <стороны-или-угла>]?, );
```
Функция принимает опциональный первый аргумент, который определяет угол градиента, и который можно выразить с помощью единицы измерения (градус, радиус, град, оборот) или в виде ключевого слова (стороны или угла.
После этого функция принимает список цветов.
#### Поле градиента
У градиентного изображения нет размеров, оно бесконечно в отличие от других фоновых изображений. Видимые размеры ему придает поле градиента, т.е. область, в которой оно отображается.
Как правило, когда вы применяете фоновое изображение в виде линейного градиента к элементу DOM, этой областью является рамка границ элемента (которая является той самой областью, в которой отображается фоновый цвет).
При этом если вы используете еще и CSS-свойство background-size (размер фона) и устанавливаете его, скажем, на 200px \* 200px, тогда поле градиента будет иметь этот размер и будет, по умолчанию, размещаться в левом верхнем углу DOM-элемента, если только вы также не установите background-position (положение фона).
Поэтому, читая следующие разделы, просто помните, что поле градиента не всегда расположено так же и имеет такие же размеры, как и DOM-элемент, к которому вы применяете этот градиент.
#### Линия градиента
В поле градиента линия, которая проходит через центр и вдоль которой распределяются цвета, называется линией градиента. Эту линию можно описать проще в ходе разъяснения угол градиента, поэтому об этом более подробно следующем разделе.
#### Угол градиента
Вполне очевидно, что угол линейного градиента используется для определения того, в каком направлении пойдет градиент. Но давайте рассмотрим этот аспект подробнее.
Если С – это центральная точка поля градиента, тогда А – это угол между вертикальной линией, проходящей через С, и линией градиента, которая также проходит через С, и вдоль которой распределяются стоп-цвета градиента.
Этот угол можно определить двумя способами:
• С помощью одного из ключевых слов: to top (вверх), to bottom (вниз), to left (влево), to right (вправо), to top right (вправо вверх), to top left (влево вверх), to bottom right (вправо вниз), to bottom left (влево вниз);
• Или путем определения угла с числом и единицей измерения, например 45deg (45 градусов), 1turn (1 оборот);
Если угол не указывается, то по умолчанию он направляется вниз (то есть это 180 градусов или 0,5 оборота):
*На этом и на следующих изображениях поле градиента ограничено прямоугольником, а линия градиента – это жирная серая линия, которая проходит через центр, и вдоль которой отображаются цвета.*
В вышеприведенном примере угол не указан, поэтому градиент от белого к красному двигается сверху вниз, что соответствует ключевому слову to bottom (вниз), как показано ниже:
И, как показано на 2 следующих изображениях, to top (вверх) соответствует углу в ноль градусов:
Еще один важный момент, который стоит учитывать, используя ключевые слова угла — что to top right (вправо вверх), например, (или любое другое ключевое слово угла) зависит от размеров поля градиента.
Логика заключается в том, что если бы вы хотели сделать градиент от красного к синему в направлении верхнего правого угла элемента, тогда такой элемент должен быть именно синим в верхнем правом углу, а фиолетовый цвет в середине градиента должен формироваться вокруг линии, которая проходит из верхнего левого в нижний правый угол. Вот как это выглядит на изображении:
Поэтому to top right (вправо вверх) не означает, что линия градиента проходит через правый верхний угол, и это даже не значит, что угол градиента равен 45 градусам!
Давайте посмотрим на то, как перемещается линия градиента при изменении угла, с помощью следующей анимации:
*На этой анимации угол наклоняется от 0 до 360 градусов с шагом в 10 градусов. Низкое разрешение GIF даже позволяет лучше рассмотреть, как различные цвета отображаются в виде «линий», которые всегда перпендикулярны линии градиента.*
Давайте вспомним, что мы знаем об углах градиента:
• Угол измеряется между линией градиента и линией, которая выходит из центра поля градиента и движется вверх.
• Поэтому 0 градусов означает вверх.
• Стандартное значение угла, если оно не указывается, это вниз, что равно 180 градусам.
• Ключевые слова угла зависят от размеров поля градиента.
#### Длина линии градиента
Прежде чем мы сможем увидеть, как распределяются цвета вдоль линии градиента, нам нужно объяснить один момент. Вы, возможно, заметили в предыдущей анимации, что цвета иногда располагаются за пределами поля градиента, что может с первого взгляда выглядеть немного странным, но это логично, если вы знаете причину.
Посмотрите на пример:
Нам нужен градиент от красного к синему с углом 45 градусов, и, ввиду соотношения сторон поля градиента, линия градиента не может проходить через правый верхний угол.
Но браузер хочет (то есть, спецификации заставляют его) сделать правый верхний угол чисто синим. Если бы мы сделали так, чтобы линия градиента начиналась и заканчивалась на краях поля, тогда бы синий цвет занял большую часть поля, а градиент бы так не расплывался.
Поэтому, чтобы это сделать, линия градиента иногда должна выходить за рамки поля градиента. При этом довольно легко узнать, где она начинается, и где заканчивается. Просто начертите линию, которая проходит через ближайший угол, и которая перпендикулярна линии градиента. Точка, где эта линия пересекает линию градиента, и есть местом начала/конца.
Фактически, если вы задает ширину поля градиента W, высоту H, и угол градиента, тогда длина линии градиента составляет:
abs(W \* sin(A)) + abs(H \* cos(A))
#### Цвета
Цвета представляют собой список, разделенный запятыми, в котором каждый элемент можно определить следующим образом:
```
<цвет> [<процентное соотношение> | <длина>]?
```
Поэтому необязательно указывать, где должны размещаться цвета на линии градиента. Например:
Ни один из цветов не имеет своего положения, поэтому браузер сам определил их позиции.
На самом простом примере только с 2 цветами, цвет 1 будет размещаться на 0% (в начале линии градиента), а цвет 2 – на 100% (в конце линии градиента).
Потом, если вы добавите третий цвет, цвет 1 у вас все равно останется на 0%, цвет 2 будет на 50%, а цвет 3 – на 100%, и так далее.
В вышеприведенном примере было задано 5 стоп-цветов, и браузер рассчитал их относительное положение как 0%, 25%, 50%, 75%, 100%. Причиной тому является равномерное распределение вдоль поля градиента.
Позицию цвета можно выразить либо с помощью процентного соотношения (по отношению к размеру линии градиента) или в виде длины CSS (где действует любая единица измерения CSS).
Вот пример:
Как вы видите, каждый из 5 стоп-цветов имеет свое положение, заданное в пикселях. Эти положения рассчитываются от начала линии градиента.
Используя такие позиции, вы можете получить несколько интересных эффектов. Например, вы можете использовать градиент, чтобы не рисовать градиент как таковой, а оставить несколько цветов:
На изображении выше 7 цветов, и они установлены таким образом, чтобы следующий цвет начинался в точно той же позиции, что и последний, что означает, что браузеру не нужно заполнять пространство между двумя стоп-цветами градиентом.
Конечно, это все мило и забавно, но что произойдет, если вы смешаете позиционированные цвета с непозиционированными? Тогда вы заставите браузер работать больше и попросите его автоматически распределять цвета, для которых вы не указали позицию:
В этом простом примере второй цвет (оранжевый) не имеет позиции, поэтому браузер сам определяет ее и находит подходящее место между ранее заданным и следующим цветом. Здесь это очень просто, так как непосредственные соседи второго цвета имеют свою позицию, но если позиции есть только у некоторых цветов, или если предыдущие или следующие цвета не имеют позиции, все усложняется.
Давайте рассмотрим несколько примеров:
На примере выше только третий цвет (желтый) позиционирован на 30%. Поэтому, чтобы лучше распределить все остальные, первый размещается на 0%, последний – на 100%, а остальные цвета распределяются в промежутке (так, что оранжевый заканчивается непосредственно между 0% и 30%, а красный – между 30% и 100%).
На примере выше первый и последний цвета позиционированы, поэтому остальные равномерно распределяются между этими двумя.
Конечно, было бы слишком просто, если бы 0% и 100% были жесткими рамками, за которые нельзя выходить. Но как видно из предыдущего примера, последний цвет расположен на 120%, и поэтому все остальные цвета должны распределяться соответствующим образом относительно данной позиции (начальной точкой по умолчанию в этом случае остается 0%).
И если вы хотите заставить свой браузер работать еще больше, почему бы не указать порядок позиций?
На самом деле цвета должны иметь порядок, но ничто не запрещает вам этого не делать, и ничего ужасного не произойдет, если вы этого не сделаете. Ваш браузер просто все исправит, как показано ниже:
Начнем с первого цвета (красного), расположенного на 30%. Дальше второй цвет расположен на 10%, что уже неправильно, так как, как сказано выше, цвета должны указываться по возрастанию позиции. Поэтому здесь браузер исправляет позицию второго цвета и устанавливает его в то же положение, что и у предыдущего цвета (30%). Далее идет третий цвет (желтый), расположенный на 60%, что правильно, но за ним следует четвертый (синий) на 40%. Опять же позиция корректируется и устанавливается на то же значение, что и предыдущего позиционированного цвета.
В конечном итоге, как показано на примере выше, последний цвет (синий) позиционируется неправильно и браузер делает его позицию такой же, как и у предыдущего цвета, который в данном случае не является ни его непосредственным соседом (желтым), ни соседом цвета, который стоит перед ним (оранжевым), поэтому он должен вернуться к первом цвету (красному). Таким образом, все цвета между красным и синим установлены в положение 30% и поэтому невидимы.
#### Инструменты
Все скриншоты в этой статье взяты из простого [инструмента](http://codepen.io/captainbrosset/pen/ByqRMB), который я сделал на codepen, и который позволяет вводить функцию линейного градиента и видеть поле градиента, линию градиента, угол, а также информацию о цветах поверх элемента.
В инструменте есть все виды багов и ограничений (см. комментарии в javascript), поэтому не ожидайте от него многого.
**Полезные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/256479/ | null | ru | null |
# Apache Bigtop и выбор Hadoop-дистрибутива сегодня
[](https://habr.com/ru/company/rostelecom/blog/499854/)
Наверное, ни для кого не секрет, что прошлый год для Apache Hadoop стал годом больших перемен. В прошлом году произошло слияние Cloudera и Hortonworks (по сути, поглощение второго), а Mapr, в виду серьезных финансовых проблем, был продан Hewlett Packard. И если несколькими годами ранее, в случае on-premises инсталляций, выбор чаще приходилось делать между Cloudera и Hortonworks, то сегодня, увы, этого выбора у нас не осталось. Сюрпризом стал еще и тот факт, что Cloudera с февраля этого года объявила о прекращении выпуска бинарных сборок своего дистрибутива в публичный репозиторий, и теперь они доступны лишь по платной подписке. Конечно, возможность загрузки последних версий CDH и HDP, выпущенных до конца 2019-го года, все еще есть, и поддержка по ним предполагается в течение одного-двух лет. Но что же делать дальше? Для тех, кто ранее платил за подписку, ничего не изменилось. А для тех, кто не хочет переходить на платную версию дистрибутива, но при этом хочет иметь возможность получать свежие версии компонентов кластера, а также патчи и прочие обновления, мы и подготовили эту статью. В ней мы рассмотрим возможные варианты выхода из сложившейся ситуации.
*Статья больше обзорная. В ней не будет сравнения дистрибутивов и подробного их разбора, а также не будет рецептов по их установке и настройке. А что же будет? Мы вкратце расскажем про такой дистрибутив как Arenadata Hadoop, который по праву заслужил наше внимание ввиду своей доступности, что на сегодня большая редкость. А затем поговорим про Vanilla Hadoop, в основном про то, как его можно “приготовить” с помощью Apache Bigtop. Готовы? Тогда добро пожаловать под кат.*
Arenadata Hadoop
----------------
Это совсем новый и, пока еще, мало кому известный дистрибутив отечественной разработки. К сожалению, на текущий момент на хабре о нем есть лишь [эта статья](https://habr.com/ru/post/454416/).
Более подробную информацию можно найти на официальном [сайте](https://arenadata.tech/products/hadoop/) проекта. Последние версии дистрибутива основаны на Hadoop 3.1.2 для 3-й версии, и 2.8.5 для 2-й версии.
Информацию о roadmap можно найти [здесь](https://arenadata.tech/products/hadoop/roadmap/).
*Интерфейс Arenadata Cluster Manager*
Ключевым продуктом Arenadata является [Arenadata Cluster Manager (ADCM)](https://arenadata.tech/products/adcm/), который используется для установки, настройки и мониторинга различных программных решений компании. ADCM распространяется бесплатно, а его функционал расширяется за счет добавления в него бандлов, которые представляют из себя набор ansible-playbooks. Бандлы делятся на два вида: enterprise и community. Последние доступны для бесплатной загрузки с сайта Arenadata. Также есть возможность разработать свой собственный бандл и подключить его к ADCM.
Для деплоя и управления Hadoop 3 предлагается community-версия бандла в связке с ADCM, а для hadoop 2 есть лишь [Apache Ambari](https://ambari.apache.org/) в качестве альтернативы. Что же касается репозиториев с пакетами, то они открыты для публичного доступа, их можно загрузить и установить привычным образом для всех компонентов кластера. В целом, дистрибутив выглядит весьма интересно. Уверен, найдутся те, кто привык к таким решениям, как Cloudera Manager и Ambari, и кому приглянется сам ADCM. Для кого-то будет огромным плюсом еще и тот факт, что дистрибутив [входит в реестр ПО](https://reestr.minsvyaz.ru/reestr/120932/) для импортозамещения.
Если говорить о минусах, то они будут теми же, что и для всех остальных дистрибутивов Hadoop. А именно:
* Так называемый «vendor lock-in». На примере Cloudera и Hortonworks мы уже поняли, что всегда есть риск изменения политики компании.
* Значительное отставание от апстрима Apache.
Vanilla Hadoop
--------------
Как вы знаете, Hadoop – это не монолитный продукт, а, по сути, целая плеяда сервисов вокруг его распределенной файловой системы HDFS. Мало кому будет достаточно одного файлового кластера. Одним нужен Hive, а другим Presto, а еще есть HBase и Phoenix, все чаще используется Spark. Для оркестрации и загрузки данных иногда встречаются Oozie, Sqoop и Flume. А если встает вопрос обеспечения безопасности, то сразу вспоминается Kerberos в связке с Ranger.
Бинарные версии компонентов Hadoop доступны на сайте каждого из проектов экосистемы в виде тарболлов. Их можно загрузить и начать установку, но с одним условием: помимо самостоятельной сборки пакетов из «сырых» бинарников, которую, вероятнее всего, вы захотите выполнить, у вас не будет никакой уверенности в совместимости загруженных версий компонентов между собой. Более предпочтительным вариантом является сборка с помощью Apache Bigtop. Bigtop позволит выполнить сборку из maven-репозиториев Apache, прогнать тесты и собрать пакеты. Но, что для нас очень важно, Bigtop соберет те версии компонентов, которые будут между собой совместимы. О нем мы и расскажем более подробно далее.
Apache Bigtop
-------------
Apache Bigtop – это инструмент для сборки, пакетирования и тестирования ряда
open source проектов, таких, например, как Hadoop и Greenplum. У Bigtop есть множество
релизов. На момент написания статьи последним стабильным релизом была версия 1.4,
а в master находилась 1.5. В разных версиях релизов используются разные версии
компонентов. Например, для 1.4 core-компоненты Hadoop имеют версию 2.8.5, а в master
2.10.0. Меняется и состав поддерживаемых компонентов. Что-то устаревшее и
необновляемое уходит, а на его место приходит что-то новое, более востребованное, и
не обязательно это что-то из семейства самого Apache.
Кроме того, у Bigtop есть множество [форков](https://github.com/apache/bigtop/network/members).
Когда мы стали знакомиться с Bigtop, то прежде всего нас удивила его скромная, в сравнении с другими проектами Apache, распространенность и известность, а также совсем небольшое комьюнити. Из этого следует, что информации по продукту минимум, а поиск решений возникших проблем по форумам и рассылкам может и вовсе ничего не дать. Поначалу для нас оказалось непростой задачей выполнить полную сборку дистрибутива в силу особенностей самого инструмента, но об этом расскажем чуточку позже.
*В качестве тизера — тем, кому в свое время заходили такие проекты Linux-вселенной, как Gentoo и LFS, возможно, покажется ностальгически приятно поработать с этой штукой и вспомнить те «былинные» времена, когда мы сами искали (а то и писали) ебилды и регулярно пересобирали с новыми патчами мозиллу.*
Большим плюсом Bigtop можно считать открытость и универсальность инструментов, на которых он основан. В его фундаменте стоят Gradle и Apache Maven. Gradle достаточно хорошо известен как инструмент, которым Google собирает Android. Он гибкий, ну и, как говорится, «проверен в бою». Maven – это штатный инструмент для сборки проектов в самом Apache, и, поскольку большинство его продуктов выпускается именно через Maven, тут тоже без него не обошлось. Стоит обратить внимание на POM (project object model) – «фундаментальный» xml-файл с описанием всего необходимого для работы Maven с вашим проектом, вокруг которого строится вся работа. Именно в
части Maven и возникают некоторые препятствия, на которые обычно наталкиваются впервые берущиеся за Bigtop.
Практика
--------
Итак, с чего же стоит начать? Идем на страницу загрузки и качаем в виде архива последнюю стабильную версию. Там же можно найти и бинарные артефакты, собранные Bigtop. Кстати говоря, из распространенных пакетных менеджеров поддерживаются YUM и APT.
Альтернативным способом, можно загрузить последний стабильный релиз напрямую с
github:
```
$ git clone --branch branch-1.4 https://github.com/apache/bigtop.git
```
Клонирование в «bigtop»…
```
remote: Enumerating objects: 46, done.
remote: Counting objects: 100% (46/46), done.
remote: Compressing objects: 100% (41/41), done.
remote: Total 40217 (delta 14), reused 10 (delta 1), pack-reused 40171
Получение объектов: 100% (40217/40217), 43.54 MiB | 1.05 MiB/s, готово.
Определение изменений: 100% (20503/20503), готово.
Updating files: 100% (1998/1998), готово.
```
Выглядит получившийся каталог ./bigtop примерно так:
`./bigtop-bigpetstore` — демонстрационные приложения, синтетические примеры
`./bigtop-ci` — инструментарий CI, jenkins
`./bigtop-data-generators` — генерация данных, синтетика, для smoke-тестов и т.д.
`./bigtop-deploy` — инструменты для деплоя
`./bigtop-packages` — конфиги, скрипты, патчи для сборки, основная часть инструмента
`./bigtop-test-framework` — фреймворк тестирования
`./bigtop-tests` — сами тесты, нагрузочные и smoke
`./bigtop_toolchain` — окружение для сборки, подготовка среды для работы инструмента
`./build` — рабочий каталог сборки
`./dl` — каталог для скачанных исходников
`./docker` — сборка в docker-образах, тестирование
`./gradle` — конфиг gradle
`./output` – каталог, в который попадают артефакты сборки
`./provisioner` — провижининг
Самым интересным на данном этапе для нас является основной конфиг `./bigtop/bigtop.bom`, в котором мы видим все поддерживаемые компоненты с версиями. Именно тут мы можем указать другую версию продукта (если вдруг мы хотим ее попробовать собрать) или версию сборки (если, например, добавили значительный патч).
Также большой интерес вызывает подкаталог `./bigtop/bigtop-packages`, имеющий непосредственное отношение к процессу сборки компонентов и пакетов с ними.
Итак, мы скачали архив, распаковали его или сделали клон с github, можно начинать сборку?
Нет, сначала подготовим окружение.
Подготовка окружения
--------------------
И тут понадобится небольшое отступление. Для сборки практически любого более или менее сложного продукта необходимо определенное окружение — в нашем случае это JDK, те же разделяемые библиотеки, заголовочные файлы и т. д., инструменты, например, ant, ivy2 и много чего еще. Одним из вариантов получить нужное для Bigtop окружение является установка нужных компонентов на хосте сборки. Могу ошибаться в хронологии, но, кажется, с версии 1.0 также появился вариант сборки в заранее сконфигурированных и доступных docker-образах, с ними можно ознакомиться тут.
Что касается подготовки окружения, то для этого есть помощник — Puppet.
Можно воспользоваться следующими командами, запуск делается из корневого каталога
инструмента, `./bigtop:`
```
./gradlew toolchain
./gradlew toolchain-devtools
./gradlew toolchain-puppetmodules
```
Или непосредственно через puppet:
```
puppet apply --modulepath= -e "include bigtop\_toolchain::installer"
puppet apply --modulepath= -e "include bigtop\_toolchain::deployment-tools"
puppet apply --modulepath= -e "include bigtop\_toolchain::development-tools"
```
К сожалению, уже на этом этапе могут возникнуть сложности. Общий совет тут – использовать поддерживаемый дистрибутив, в актуальном состоянии на хосте сборки либо пробовать путь с docker.
Сборка
------
Что же мы можем попробовать собрать? Ответ на этот вопрос даст вывод команды
```
./gradlew tasks
```
В разделе Package tasks есть ряд продуктов являющихся конечными артефактами Bigtop.
Их можно определить по суффиксу -rpm или -pkg-ind (в случае сборки
в docker). В нашем случае самым интересным является Hadoop.
Попробуем выполнить сборку в окружении нашего build-сервера:
```
./gradlew hadoop-rpm
```
Bigtop сам скачает необходимые исходники, нужные для конкретного компонента, и начнет сборку. Таким образом, работа инструмента завязана на репозиториях Maven и других источниках, то есть ему нужен доступ в Интернет.
В процессе работы формируется стандартный вывод. Иногда по нему и сообщениям об ошибках можно понять, что пошло не так. А иногда требуется получить дополнительную информацию. В этом случае стоит добавить аргументы `--info` или `--debug`, а также может быть полезен `–stacktrace`. Есть удобный способ сформировать набор данных для последующего обращения в списки рассылки, ключ `--scan`.
С его помощью bigtop соберет всю информацию и выложит в gradle, после чего выдаст ссылку,
пройдя по которой, компетентный человек сможет понять, почему сборка не удалась.
Нужно иметь в виду, что эта опция может сделать публичной нежелательную для вас информацию, например, имена пользователей, нод, переменные окружения и т.д., так что будьте осторожны.
Часто ошибки являются следствием невозможности получить какие-либо необходимые для сборки компоненты. Как правило, исправить проблему можно через создание патча для исправления чего-либо в исходниках, например, адреса в pom.xml в корневом каталоге исходников. Это делается через создание и размещение его в соответствующем каталоге `./bigtop/bigtop-packages/src/common/oozie/` патча, например, в виде *patch2-fix.diff.*
```
--- a/pom.xml
+++ b/pom.xml
@@ -136,7 +136,7 @@
central
- http://repo1.maven.org/maven2
+ https://repo1.maven.org/maven2
false
```
Скорее всего, на момент чтения этой статьи, указанное выше исправление вам не придется делать самим.
При внедрении каких-либо патчей и правок в механизм сборки может понадобиться «сбросить» сборку через команду очистки:
```
./gradlew hadoop-clean
> Task :hadoop_vardefines
> Task :hadoop-clean
BUILD SUCCESSFUL in 5s
2 actionable tasks: 2 executed
```
Эта операция откатит все изменения по сборке данного компонента, после чего сборка выполнится заново. В этот раз попробуем собрать проект в docker-образе:
```
./gradlew -POS=centos-7 -Pprefix=1.2.1 hadoop-pkg-ind
> Task :hadoop-pkg-ind
Building 1.2.1 hadoop-pkg on centos-7 in Docker...
+++ dirname ./bigtop-ci/build.sh
++ cd ./bigtop-ci/..
++ pwd
+ BIGTOP_HOME=/tmp/bigtop
+ '[' 6 -eq 0 ']'
+ [[ 6 -gt 0 ]]
+ key=--prefix
+ case $key in
+ PREFIX=1.2.1
+ shift
+ shift
+ [[ 4 -gt 0 ]]
+ key=--os
+ case $key in
+ OS=centos-7
+ shift
+ shift
+ [[ 2 -gt 0 ]]
+ key=--target
+ case $key in
+ TARGET=hadoop-pkg
+ shift
+ shift
+ [[ 0 -gt 0 ]]
+ '[' -z x ']'
+ '[' -z x ']'
+ '[' '' == true ']'
+ IMAGE_NAME=bigtop/slaves:1.2.1-centos-7
++ uname -m
+ ARCH=x86_64
+ '[' x86_64 '!=' x86_64 ']'
++ docker run -d bigtop/slaves:1.2.1-centos-7 /sbin/init
+
CONTAINER_ID=0ce5ac5ca955b822a3e6c5eb3f477f0a152cd27d5487680f77e33fbe66b5bed8
+ trap 'docker rm -f
0ce5ac5ca955b822a3e6c5eb3f477f0a152cd27d5487680f77e33fbe66b5bed8' EXIT
....
много вывода
....
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-yarn-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-mapreduce-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-namenode-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-secondarynamenode-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-zkfc-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-journalnode-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-datanode-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-httpfs-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-yarn-resourcemanager-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-yarn-nodemanager-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-yarn-proxyserver-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-yarn-timelineserver-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-mapreduce-historyserver-2.8.5-
1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-client-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-conf-pseudo-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-doc-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-libhdfs-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-libhdfs-devel-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-hdfs-fuse-2.8.5-1.el7.x86_64.rpm
Wrote: /bigtop/build/hadoop/rpm/RPMS/x86_64/hadoop-debuginfo-2.8.5-1.el7.x86_64.rpm
+ umask 022
+ cd /bigtop/build/hadoop/rpm//BUILD
+ cd hadoop-2.8.5-src
+ /usr/bin/rm -rf /bigtop/build/hadoop/rpm/BUILDROOT/hadoop-2.8.5-1.el7.x86_64
Executing(%clean): /bin/sh -e /var/tmp/rpm-tmp.uQ2FCn
+ exit 0
+ umask 022
Executing(--clean): /bin/sh -e /var/tmp/rpm-tmp.CwDb22
+ cd /bigtop/build/hadoop/rpm//BUILD
+ rm -rf hadoop-2.8.5-src
+ exit 0
[ant:touch] Creating /bigtop/build/hadoop/.rpm
:hadoop-rpm (Thread[Task worker for ':',5,main]) completed. Took 38 mins 1.151 secs.
:hadoop-pkg (Thread[Task worker for ':',5,main]) started.
> Task :hadoop-pkg
Task ':hadoop-pkg' is not up-to-date because:
Task has not declared any outputs despite executing actions.
:hadoop-pkg (Thread[Task worker for ':',5,main]) completed. Took 0.0 secs.
BUILD SUCCESSFUL in 40m 37s
6 actionable tasks: 6 executed
+ RESULT=0
+ mkdir -p output
+ docker cp
ac46014fd9501bdc86b6c67d08789fbdc6ee46a2645550ff6b6712f7d02ffebb:/bigtop/build .
+ docker cp
ac46014fd9501bdc86b6c67d08789fbdc6ee46a2645550ff6b6712f7d02ffebb:/bigtop/output .
+ docker rm -f ac46014fd9501bdc86b6c67d08789fbdc6ee46a2645550ff6b6712f7d02ffebb
ac46014fd9501bdc86b6c67d08789fbdc6ee46a2645550ff6b6712f7d02ffebb
+ '[' 0 -ne 0 ']'
+ docker rm -f ac46014fd9501bdc86b6c67d08789fbdc6ee46a2645550ff6b6712f7d02ffebb
Error: No such container:
ac46014fd9501bdc86b6c67d08789fbdc6ee46a2645550ff6b6712f7d02ffebb
BUILD SUCCESSFUL in 41m 24s
1 actionable task: 1 executed
```
Сборка выполнилась под CentOS, но можно выполнить и под Ubuntu:
```
./gradlew -POS=ubuntu-16.04 -Pprefix=1.2.1 hadoop-pkg-ind
```
Кроме сборки пакетов под различные дистрибутивы Linux, инструмент умеет формировать репозиторий с собранными пакетами, например:
```
./gradlew yum
```
Также можно вспомнить про smoke-тесты и развертывание в docker.
Создать кластер из трех нод:
```
./gradlew -Pnum_instances=3 docker-provisioner
```
Запустить smoke-тесты в кластере из трех нод:
```
./gradlew -Pnum_instances=3 -Prun_smoke_tests docker-provisioner
```
Удалить кластер:
```
./gradlew docker-provisioner-destroy
```
Получить команды для подключения внутрь docker-контейнеров:
```
./gradlew docker-provisioner-ssh
```
Показать состояние:
```
./gradlew docker-provisioner-status
```
Более подробно про Deployment tasks можно почитать в документации.
Если говорить про тесты, то их достаточно большое количество, в основном smoke и интеграционные. Их разбор находится за рамками данной статьи. Скажу лишь, что сборка дистрибутива не является настолько сложной задачей, какой может показаться на первый взгляд. Все компоненты, которые мы используем у себя в проде, удалось собрать и пройти по ним тесты, а также у нас не возникло проблем с их деплоем и выполнением базовых операций в тестовом окружении.
Кроме имеющихся компонентов в Bigtop, есть возможность добавить что-либо еще, даже собственную программную разработку. Все это отлично автоматизируется и укладывается в концепцию CI/CD.
Заключение
----------
Очевидно, что собранный таким образом дистрибутив не следует сразу же отправлять в продакшн. Нужно понимать, что если есть реальная потребность в сборке и поддержке своего дистрибутива, то в это нужно вкладываться финансово и временем.
Тем не менее, в сочетании с правильным подходом и профессиональной командой вполне можно обойтись и без коммерческих решений.
Важно отметить, что сам проект Bigtop нуждается в развитии и, похоже, что на сегодня активной разработки в нем не происходит. Также непонятна перспектива появления в нем Hadoop 3. К слову, если у вас есть реальная потребность в сборке Hadoop 3, то можете посмотреть на [форк](https://github.com/arenadata/bigtop) от Arenadata, в котором помимо стандартных
компонентов есть еще целый ряд дополнительных (Ranger, Knox, NiFi).
Что касается Ростелекома, то для нас Bigtop – это один из рассматриваемых вариантов на сегодняшний день. Остановим мы свой выбор на нем или нет – покажет время.
Appendix
--------
Чтобы включить новый компонент в сборку, нужно добавить его описание в bigtop.bom и ./bigtop-packages. Можно попробовать сделать это по аналогии с имеющимися компонентами. Попробуйте разобраться. Это не так сложно, как кажется на первый взгляд.
А что думаете вы? Будем рады увидеть ваше мнение в комментариях и спасибо за внимание!
*Статья подготовлена командой управления данными «Ростелекома»* | https://habr.com/ru/post/499854/ | null | ru | null |
# 7 мифов о Linq to Database
Linq появился в 2007 году, тоже же появился первый IQueryable-провайдер — Linq2SQL, он работал только с MS SQL Server, довольно сильно тормозил и покрывал далеко не все сценарии. Прошло почти 7 лет, появилось несколько Linq-провайдеров, которые работают с разными СУБД, победили почти все «детские болезни» технологии и, уже пару лет как, Linq to Database (обобщенное название для популярных провайдеров) готов к промышленному применению.
Тем не менее далеко не все применяют Linq to Database и объясняют это не только тем, что проект старый и переписать на linq довольно сложно, но и приводят в качестве аргументов различные мифы. Эти мифы кочуют из одной компании в другую и часто распространяются через интернет.
В этом посте я собрал самые популярные мифы и опровержения к ним.
#### Миф №1
###### Базой данных занимается специально обученный DBA, который делает все запросы, а программисты пишут код, поэтому Linq to Database не нужен.
Несмотря на всю привлекательность мифа обычно такой подход не работает. Чтобы сделать эффективные запросы DBA должен очень хорошо понимать что происходит в программе, какие данные нужны в каждом сценарии.
Если DBA не обладает таким знанием, то обычно сводится к тому, что DBA делает небольшой набор CRUD хранимок на каждую сущность + несколько хранимок для самых «толстых» запросов. А остальное уже делается программистами в коде. Это чаще всего неэффективно работает, потому что в среднем тянется сильно больше данных, чем нужно для конкретного сценария. И оптимизировать такое сложно.
Если же DBA знает каждый сценарий, то у него два варианта:
а) Сделать много хранимок (почти одинаковых), каждую под конкретный сценарий, а потом мучительно их поддерживать.
б) Сделать несколько универсальных хранимок с кучей параметров, внутри которых клеить строки для формирования оптимальных запросов. Причем добавление дополнительного параметра в запрос становится крайне сложным процессом.
Оба варианта для DBA очень сложны, поэтому чаще всего получается гибридный вариант с несколькими очень сложными хранимками, а все остальное — банальный CRUD. Linq позволяет делать ту же самую склейку строк гораздо эффективнее, поэтому можно в коде программы генерировать оптимальные запросы или близкие к оптимальным.
DBA может создать представления и функции, которые будут использоваться в запросах из кода приложения, а также хранимые процедуры для пакетной обработки. Но конструирование запросов лучше оставить на стороне приложения.
#### Миф №2
###### Linq генерирует неэффективные SQL запросы.
Очень часто повторяемый миф. Но большая часть неэффективности Linq запросов создается людьми.
Причины этому простые:
1) Люди не понимают чем отличается Linq от SQL. Linq работает с упорядоченными последовательностями, а SQL с неупорядоченными множествами. Поэтому некоторые Linq операции добавляют в SQL крайне неэффективные операторы сортировки.
2) Люди не понимают механизмов работы IQuryable-провайдеров и как выполняются запросы в СУБД. Подробнее в предыдущем посте — [habrahabr.ru/post/230479](http://habrahabr.ru/post/230479)
Но есть и баги в провайдерах, которые приводят к генерации запросов, далеких от оптимальных.
Например в Entity Framework есть баг при использовании навигационных свойств:
```
context.Orders
.Where(o => o.Id == id)
.SelectMany(o => o.OrderLines)
.Select(l => l.Product)
.ToList();
```
Такой запрос генерирует следующий SQL:
**Много кода**
```
[Project1].[Id] AS [Id],
[Project1].[OrderDate] AS [OrderDate],
[Project1].[UserId] AS [UserId],
[Project1].[C1] AS [C1],
[Project1].[OrderId] AS [OrderId],
[Project1].[ProductId] AS [ProductId],
[Project1].[Id1] AS [Id1],
[Project1].[Title] AS [Title]
FROM ( SELECT
[Extent1].[Id] AS [Id],
[Extent1].[OrderDate] AS [OrderDate],
[Extent1].[UserId] AS [UserId],
[Join1].[OrderId] AS [OrderId],
[Join1].[ProductId] AS [ProductId],
[Join1].[Id] AS [Id1],
[Join1].[Title] AS [Title],
CASE WHEN ([Join1].[OrderId] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1]
FROM [dbo].[Orders] AS [Extent1]
LEFT OUTER JOIN (SELECT [Extent2].[OrderId] AS [OrderId], [Extent2].[ProductId] AS [ProductId], [Extent3].[Id] AS [Id], [Extent3].[Title] AS [Title]
FROM [dbo].[OrderLines] AS [Extent2]
INNER JOIN [dbo].[Products] AS [Extent3] ON [Extent2].[ProductId] = [Extent3].[Id] ) AS [Join1] ON [Extent1].[Id] = [Join1].[OrderId]
WHERE [Extent1].[Id] = @p__linq__0
) AS [Project1]
ORDER BY [Project1].[Id] ASC, [Project1].[C1] ASC
```
В этом запросе вычисляемое поле и сортировка по нему не могут быть соптимизированы SQL Server и приходится выполнять реальную сортировку.
Но если немного переписать Linq запрос на использование оператора join, то проблемы не будет:
```
var orders1 = from o in context.Orders
where o.Id == id
join ol in context.OrderLines on o.Id equals ol.OrderId into j
from p in j.DefaultIfEmpty()
select p.Product;
orders1.ToArray();
```
Полученный SQL:
```
SELECT
[Extent3].[Id] AS [Id],
[Extent3].[Title] AS [Title]
FROM [dbo].[Orders] AS [Extent1]
LEFT OUTER JOIN [dbo].[OrderLines] AS [Extent2] ON [Extent1].[Id] = [Extent2].[OrderId]
LEFT OUTER JOIN [dbo].[Products] AS [Extent3] ON [Extent2].[ProductId] = [Extent3].[Id]
WHERE [Extent1].[Id] = @p__linq__0
```
Он отлично покрывается индексами и оптимизируется SQL Server.
Также слышал о неэффективных запросах NHibernate, но не работал с ним настолько активно, чтобы найти такие баги.
#### Миф №3
###### Медленно работает маппинг.
Само преобразование DataReader в набор объектов выполняется за доли **микро**секунды на каждый объект. Причем linq2db провайдер умудряется делать это быстрее, чем разрекламированный Dapper.
А вот что может работать медленно, так это присоединение полученных объектов к Change Tracking контексту. Но это необходимо выполнять только в случае, когда объекты будут изменены и записаны в базу. В остальных случаях можно явно указать чтобы объекты не присоединялись к контексту или использовать проекции.
#### Миф №4
###### Медленно генерируются запросы.
Действительно для генерации SQL запроса из Linq требует обхода дерева, много работы с рефлексией и анализ метаданных. Но во всех провайдерах такой анализ проводится один раз, а потом данные кешируются.
В итоге для простых запросов генерация запроса выполняется в среднем за 0,4мс. Для сложных это может быть до нескольких миллисекунд.
Это время обычно меньше статистической погрешности от общего времени выполнения запроса.
#### Миф №5
###### Нельзя использовать хинты.
В SQL Server есть механизм Plan Guide, который позволяет навесить хинты на любой запрос. Аналогичные механизмы есть и в других СУБД.
Но даже при этом хинты не сильно нужны при использовании Linq. Linq генерирует довольно простые запросы, которые СУБД самостоятельно оптимизирует при наличии статистики, индексов и ограничений. Хинты блокировок лучше заменить на выставление правильных уровней изоляции и ограничение количества запрашиваемых строк.
#### Миф №6
###### В Linq нельзя использовать все возможности SQL.
Отчасти это правда. Но многие возможности SQL можно завернуть в функции или представления, а их уже использовать в Linq запросах.
Более того, Entity Framework позволяет выполнять любые SQL запросы, а результаты мапить на объекты, в том числе с Change Tracking.
#### Миф №7
###### Хранимые процедуры работают быстрее ad-hoc запросов, генерируемых Linq.
Это было актуально в середине 90-х годов. Сегодня все СУБД «компилируют» запросы и кешируют планы, независимо от того процедура это или ad-hoc запрос.
Вот краткий набор мифов, которые можно встретить. Если у вас есть еще — дополняйте. | https://habr.com/ru/post/230623/ | null | ru | null |
# Redux store: Расширение по «горизонтали»
 Когда приложение, использующее [Redux](http://redux.js.org/), разрастается до достаточно больших размеров, количество состояний увеличивается многократно. Для разделения редьюсеров на логические единицы применяется подход комбинирования их с помощью [combineReducers](http://redux.js.org/docs/api/combineReducers.html#combinereducersreducers). Данное решение позволяет расширить [store](http://redux.js.org/docs/basics/Store.html) по «вертикали». Но бывают случаи, когда данного разделения может быть недостаточно. Например, один из уровней несет в себе составную логику, которую тоже было бы неплохо разделить (или как говорил один из известных людей: «Ухлубить!»). Но такого подхода нет в API Redux. И поиск решения данного вопроса так же ничего не дал (может плохо искал). Поэтому я разработал свой подход расширения по «горизонтали» Redux Store.
Хочу Вас ознакомить со [своим проектом](https://github.com/kolesoffac/redux-combine-deep-props), который позволяет осуществить данный подход.
### Использование
1) Сначала, на уровне редьюсера первого уровня, подключаем саму библиотеку:
```
import {stateCombine, runCombine, getInitialState} from "redux-combine-deep-props";
```
2) Подключаем редьюсер для второго уровня:
```
import level2Module from "./reducer-level-2";
```
3) Формируем начальные значения для первого уровня:
```
let initialState = {
propLevel1: ...,
...
propLevelN: ...
};
```
4) Создаем объект комбинаций:
```
let combinations = {
: {
module: level2Module
}
};
```
где мы задаем название будущего раздела *name prop*, и для него — редьюсер этого уровня, ~~а так же набор типов эшенов для триггеринга изменения стейта данного уровня~~.
5) Создаем функцию-обработчик текущего стейта:
```
let combineDeepProp = stateCombine(combinations);
let combine = runCombine(combinations, combineDeepProp);
```
6) Для обработки начальных значений всех уровней создаем комбинированный initial state.
```
const combineInitialState = getInitialState(combinations, initialState);
```
7) В экспортной функции-редьюсере используем комбинированный *initial state*, а в ее теле строго до любого изменения состояния запускаем обработчик всех комбинаций, который меняет нужным образом текущее состояние, если текущий тип экшена совпал с заданными:
```
export default function level1Module (state = combineInitialState, action) {
...
let newState = combine(state, action);
...
switch (action.type) {
case "....":
newState = {
...newState,
...
};
break;
...
};
...
return newState;
};
```
8) Модуль второго уровня оформляется по стандартной схеме, с учетом, что стейт в нем представлен в разрезе этого уровня:
```
let initialState = {
...
};
export default function search(state = initialState, action) {
...
switch (action && action.type) {
...
};
};
```
но с одним отличием — должна быть проверка на *undefined* текущего *action*. Сделано для задание *initial state* при первом проходе в методе *getInitialState*.
### Заключение
Данный подход позволяет в рекурсивном режиме расширить до бесконечности текущий уровень и по «вертикали», за счет использованием в комбинациях более одного объекта:
```
let combinations = {
: {
module: level2Module1
},
...
: {
module: level2ModuleN
}
};
```
и по «горизонтали», за счет использования описанного выше подхода на каждом из 2+ уровней.
→ [Исходники](https://github.com/kolesoffac/redux-combine-deep-props)
**UPD:**
Полный рефакторинг кода, большое спасибо [dagen](https://habrahabr.ru/users/dagen/), за указание на проблему мутабельности. Теперь немного поменялся принцип использования, смотрите п.7 и п.4 — набор экшенов теперь отсутствует за ненадобностью, но комбинации пока оставил как объект для возможного дальнейшего расширения функционала. Замечу, что данный подход я использовал со связкой с [PolymerJS](https://www.polymer-project.org/), а потом с [VueJS](https://vuejs.org/), и использовал для интеграции с [Redux](http://redux.js.org/) библиотеки [polymer-redux](https://github.com/tur-nr/polymer-redux) и [vuedeux](https://github.com/Vuedeux/vuedeux) соответственно. И так как там бинд на конкретные свойства стейта идут по пути, то меня и миновала проблема мутаций, так как было необязательно мутировоать рутовый стейт при мутировании одного из поддеревьев.
**UPD2:**
Добавил сборщик [rollup](https://habrahabr.ru/post/331412/) для компиляции проекта | https://habr.com/ru/post/335868/ | null | ru | null |
# Защищаем API – что важно знать?
В фундаменте каждой информационной защиты лежит глубокое понимание технологии целевой системы. В этой статье речь пойдет о защите API (Application Programming Interface) — важнейшего набора функций для каждого прогера.
Интересно узнать об актуальных инструментах защиты API и о том, почему их важно применять? Го под кат!
Что за зверь такой — API?
-------------------------
Давайте разберемся для начала, что в наше время подразумевается под API. На данном этапе развития человечества актуальными в b2b-среде считаются микросервисные архитектуры, веб-приложения, бессерверные вычисления и т.д. Для того, чтобы весь механизм работал, необходим понятный и безусловный операнд ([аргумент операции](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D0%BD%D0%B4#:~:text=%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%CC%81%D0%BD%D0%B4%20(%D0%B0%D0%BD%D0%B3%D0%BB.%20operand)%20%D0%B2%20%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B5,%D0%B3%D0%B4%D0%B5%20%D0%B4%D0%BE%D0%BB%D0%B6%D0%B5%D0%BD%20%D1%81%D1%82%D0%BE%D1%8F%D1%82%D1%8C%20%D0%B0%D1%80%D0%B3%D1%83%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8)). Но что, если этих аргументов нужно больше? Правильным ответом будет передача функции.
Звучит достаточно просто и понятно: приложение А должно передать приложению Б набор функций для выполнения определенных действий. Пример: веб-приложение разработчика написано на Java, но есть клиентский агент, написанный на C++, и для передачи данных о клиентском агенте необходима выборка информации. Клиент с помощью функций генерирует JSON файл с содержанием этих данных и сервер веб-приложения, переваривая эту информацию, выводит в веб-интерфейс данные об этом клиенте.
Упоминая JSON файл, я забежал вперед. Для начала считаю необходимым описать возможные категоризации API:
По принципу распространения:
* Приватные — API используются в рамках одной инфраструктуры, никаким образом не интегрируются с посторонними системами. Основная цель — полный контроль одной компании над API.
* Партнерские — API открыты для партнерских инфраструктур, никаким образом не интегрируются с публичными пользователями. Обычно используются для интеграции двух и более систем в рамках партнерских соглашений или географически распределенных офисов одной компании;
* Внешние — API используются сторонними разработчиками, в основном для публичного взаимодействия с системами. Ярким примером является [API ВКонтакте](https://dev.vk.com/api/getting-started) для внедрения разработчиками игр своего кода непосредственно в маркетплейс VK.
Исторически сложилось, что изначально API использовались разработчиками приватно в рамках компаний или партнерских отношений, но в 2000-х компания «Saleforce» впервые использовала API для своих веб-приложений. Эту идею быстро подхватили будущие мастодонты рынка — eBay, Amazon и т.д. Таким образом идея использования API получила широкое распространение в сети Интернет.
Сейчас почти каждая компания, вне зависимости от ее размеров, так или иначе делает API доступным. Спектр использования весьма разнообразен: это и рынок IoT, и наши с вами смартфоны, и все переносимые устройства. Да, даже ваш умный пылесос от Xiaomi (не реклама) (который топ за свои деньги) также обладает открытым API.
Все ранее описанное нужно для понимания масштаба использования API. Но вот что я вам скажу, приведя красивую цитату: «Взломать можно все, особенно, если это придумано человеком». В подкрепление своих слов привожу статистику с сайта <https://salt.security/api-security-trends>:
Как можно наблюдать с ростом количества API вызовов растет и рост интереса злоумышленников к данному вектору атаки.
Необходимо понимать, что безусловным лидером по величине интереса хакеров являются открытые API веб-приложений и в данной статье речь будет в основном о них, иногда затрагивая API инфраструктуры разработчиков.
Итак, среди существующих общедоступных и общеизвестных API, актуальными являются API на базе следующих архитектур:
* REST — стандарт представляет собой набор рекомендаций для масштабируемых, облегченных и простых в использовании API. На данный момент самый популярный подход. Общие правила следующие:
o Ресурс является частью URL
o Для каждого ресурса создается два URL, один для коллекции, один для экземпляра коллекции, /users и users/123.
o HTTP-методы GET, POST, PATCH и DELETE информируют сервер о том, какое действие нужно совершить над данным ресурсом. Различные методы, примененные к одному и тому же ресурсу, выполняют различную функциональность.
* SOAP — расширение протокола XML-RPC. Первоначально предназначался для RPC (вызова удаленных процедур), сейчас чаще используется для обмена сообщениями в формате XML. Чаще всего встречается в сервисах типа мессенджеров (см. Mattermost).
* RPC — самый просто тип API, когда вызов передается в качестве полезной нагрузки в запросе, например:
POST /api/conversations.archive
HOST slack.com
Content-Type: application/x-www-form-urlencoded
Authorization: token OAUTH-TOKEN
channel=C01234
Почему важно защищать API?
--------------------------
Бизнес потери. Самая первая и очевидная причина потери при текущих бизнес процессах компании. Любое нарушение в информационной логике требует время на восстановление, и для каких-то компании некритично, что у сотрудников нет доступа к личному кабинету, но для других это может оказаться причиной полного уничтожения бизнеса в целом. Представьте себе на минуту, если окажется недоступным приложение вашего брокера.
Государственное регулирование. Очевидно, что при любой деятельности, связанной с данными ограниченного доступа, вопрос защиты информации приобретает, скажем так, «немного неприятный оттенок голубого неба над головой» (если понимаете, о чем я).
Репутационный ущерб — поверьте, в эпоху информационного шума и огромного количества раздува любого инфоповода, дела могут дойти до полного отказа сотрудничества с вашей компанией при малейшей утечке данных или информации о том, что ваша система уязвима.
Потеря производительности — любая атака может нести за собой разные цели. В том числе эксплуатация ваших ресурсов как следствие потеря их производительности.
Среди известных атак на API существуют:
* Атака на параметры: наиболее распространенный тип атаки, нацеленный на манипуляцию десериализатора движка целевого сервера веб-приложения.
* Атака для раскрытия данных (Exposure data): разумеется, компрометация данных и их дальнейшее использование, неважно со злым или добрым намерением является также одним из векторов атак.
* Атаки MITM (Man in the middle): атака по середине между API сервером и клиентом.
* Абуз приложений (Злоупотребление если по-русски, тем не менее абуз слово наиболее подходящее): не столь популярный тип атаки, тем не менее о нем необходимо упомянуть. Пример: у вас есть приложение по букингу билетов. С помощью приложения на телефоне человек может забронировать определенные билеты в определенных местах зала. Делается это очевидно с помощью API. Так как это общедоступное приложение, появляется маневр для злоупотребления (абуза) данного функционала. С помощью ботов или просто вручную можно забронировать все места в зале, соответственно нарушив бизнес-процесс.
Также более подробно можно [познакомиться тут](https://owasp.org/www-project-api-security/).
Какие уязвимости у API?
-----------------------
Когда мы говорим об архитектуре REST чаще всего на ум приходит — JSON (хотя RESTfull API подразумевает под собой необязательно передачу только JSON файла, но тем не менее).
Вот [тут крутая статья](https://habr.com/ru/post/554274/), кто вообще не понимает, что здесь происходит.
#### JSON уязвимости и их защита
Необходимо пояснить, что, разумеется, большинство атак на API нацелены именно на внутренние движки приложений и в полезной нагрузке (пейлоаде) могут быть любые сигнатуры (SQL инъекции, RCE, XSS, DoS и т.д.). Здесь я опишу именно специфичные уязвимости самих технологий API.
Как ранее упоминалось в статье, одна из атак нацелена на параметры. Как же это происходит?
На примере JSON в рамках официального RFC существует открытое руководство по некоторым темам, таким как обработка повторяющихся ключей и представление чисел. Хотя и в стандарте есть пункт об отказе совместимости, множество пользователей даже не знают о них.
Итак, первая категория уязвимостей JSON:
**Неопределенный приоритет повторяющихся ключей.**
Что будет если просто продублировать JSON ключ?
Например:
Test = { “bro”:1, “bro”:2}
Какое значение для bro будет итоговым при генерации такого запроса: 1 или 2, или будет ошибка? Согласно официальному стандарту оба варианта возможны (J). Причина, почему так возможно, кроется, как мне кажется, в том, что стандарт заранее сделан таким образом, чтобы не нарушать обратную совместимость с анализаторами предварительной спецификации.
Какая разница 2 или 1, или ошибка? Представим, что у вас сервис с платежной системой, можно покупать объекты для определенного ВАШЕГО аккаунта. Вы хотите купить пачку чипсов и 5 пачек жвачки:
```
POST /cart/checkout HTTP/1.1
...
Content-Type: application/json
{
"orderId": 10,
"paymentInfo": {
//...
},
"shippingInfo": {
//...
},
"cart": [
{
"id": 0,
"qty": 5
},
{
"id": 1,
"qty": -1,
"qty": 1
}
]
}
```
Где id чипсов — 1, id жвачки - 0 а их количество — qty. Пачка чипсов стоит при этом 100 рублей. При отправке такого запроса к веб-серверу, который использует для анализа JSON стандартную библиотеку Python, будет использоваться приоритет последнего ключа. Такой запрос успешно валидируется данным парсером и сырые данные отправляются дальше в систему генерации платежной квитанции, которая в свою очередь использует Golang для анализа (например, buger/jsonparser).
```
id, _ := jsonparser.GetInt(value, "id")
qty, _ := jsonparser.GetInt(value, "qty")
total = total + productDB[id]["price"].(int64) * qty;
```
Он же (Golang) использует приоритет первого ключа. Таким образом, если мы отправим запрос на 5 пачек жвачки стоимостью 500 рублей и чипсов стоимостью 100 рублей с дубликатом ключа, парсер веб-сервера проанализировав запрос (относительно json схемы) примет его как валидный, а данные, отправленные на сервис платежной системы сформируют квитанцию для qty размером -1.
Таким образом, при формировании платежной квитанции нам будет отправлено 5 пачек жвачки и 1 пачка чипсов стоимостью 500 рублей, но с нас возьмут 400 рублей, т.к. при qty -1 для пачки чипсов - их цена в чеке будет вычтена парсером Golang.
**Следующий тип атаки — коллизия значений.**
Некоторые парсеры JSON сокращают спецсимволы, когда они появляются в строковом значении, но некоторые этого не делают, и в таком случае парсер может принять дублируемое значение переменной. Например, JSON следующего типа:
```
{"test": 1, "test\[raw \x0d byte]": 2}
{"test": 1, "test\ud800": 2}
{"test": 1, "test"": 2}
{"test": 1, "te\st": 2}
```
Эти строковые значения обычно не устойчивы к нескольким этапам сереализации и десереализации. Так, U+D800 и U+DFFF являются непарными суррогатными кодовыми точками в UTF-16 и пока они могут быть закодированы в UTF-8 байтовую строку, это будет уязвимостью. Предположим, что у нас есть приложение, в котором администратор приложения может создавать роли и пользователей через API. Также пользователи с повышенными правами имеют роль — superuser. Формат создания пользователя такой:
```
POST /user/create HTTP/1.1
...
Content-Type: application/json
{
"user": "NoviiPolzak",
"roles": [
"superuser"
]
}
HTTP/1.1 401 Not Authorized
...
Content-Type: application/json
{"Error": "Assignment of internal role 'superuser' is forbidden"}
```
Как мы видим, при попытке добавления пользователя “NoviiPolzak” с ролью “superuser” сервер отвечает ошибкой 401 и контентом, что доступ запрещен. Теперь самое интересное, с помощью API мы добавим новую роль следующим образом:
```
POST /role/create HTTP/1.1
...
Content-Type: application/json
{
"name": "superuser\ud888"
}
HTTP/1.1 200 OK
...
Content-type: application/json
{"result": "OK: Created role 'superuser\ud888'"}
```
Также создадим еще раз пользователя:
```
POST /user/create HTTP/1.1
...
Content-Type: application/json
{
"user": "NoviiPolzak",
"roles": [
"superuser\ud888"
]
}
HTTP/1.1 200 OK
...
Content-Type: application/json
{"result": "OK: Created user “NoviiPolzak”}
```
Таким образом в системе на данный момент создан пользователь NoviiPolzak с ролью superuser\ud888 и при использовании парсера, который сокращает запрещенные кодовые точки система будет принимать просто роль “superuser”. То есть, когда с созданной записью пользователя мы будем обращаться, например, к панели администратора, система даст нам повышенные права.
Как известно, многие библиотеки JSON поддерживают комментирование из JavaScript интерпретатора, например /\*,\*/. Благодаря этому один запрос может быть обработан двумя разными парсерами по-разному:
```
obj = {"description": "Коллизия с помощью комментирования ", "test": 2, "extra": /*, "test": 1, "extra2": */}
```
GoLang распарсит так:
```
Description: “Коллизия с помощью комментирования”
Test= 2
Extra= “”
```
Java JSON-iterator — вот так:
```
Description:
Extra=”/*”
Extra2=”*/”
Test= 1
```
Выходит, основные уязвимости JSON связаны непосредственно с парсерами данных на стороне приложения во время их кодировки и декодирования. Такие уязвимости достаточно тяжело обнаружить, и они требуют общего подхода к их устранению — как со стороны разработчика, так и от команды ИБ. Ниже я опишу, какие существуют средства защиты API, а сейчас переходим к SOAP.
#### SOAP уязвимости
SOAP, как известно, в своем фундаменте имеет XML и основные уязвимости вытекают отсюда.
**SOAP injection** — самая простая, но тяжело детектируемая атака, непосредственно инъекция в теле SOAP запроса.
```
Ivan
Ivanov
lmao1337
```
Это классический запрос авторизации, и если он пройдет успешно, мы получим ответ ОК. Но теперь уберем тэг из запроса. В ответ от сервера получим, что-то вроде:
```
Error at line 66: lname == null | loginid
loginid cannot be null
```
Вообще данный ответ содержит в себе кусок кода, и говорит нам о том, что если lname тэг отсутствует, то должен использоваться loginid вместо него. Получается, если мы создадим запрос, в котором укажем loginid без строки :
```
Ivan
lmao1337
1
```
То мы сможем успешно авторизоваться и отправлять запросы на уровне администратора.
Да, вот такая банальная проблема может возникнуть и
дать злоумышленнику не только информацию при генерации запроса, но и
возможность несанкционированного доступа.
**SOAP Action Spoofing** — сам SOAP допускает использование дополнительного заголовка HTTP – SOAPAction. Данный заголовок содержит в себе имя выполняемой операции и служит для оптимизации анализа SOAP целевым приложением. Приложение, основываясь на заголовке, может не производить анализ целого пересылаемого XML.
Допустим, у нас есть приложение, уязвимое к SOAPAction — спуфингу по двум операциям: “createUser” и “deleteAllUsers”. При этом, перед приложением стоит шлюз, который блокирует все запросы на удаление всех пользователей, если они пришли извне (deleteAllUsers), т.е. только прямое подключение к приложению позволяет авторизованному пользователю выполнить удаление.
Пример запроса пользователя на создание нового пользователя:
```
POST /service HTTP/1.1
Host: myHost
SOAPAction: "createUser"
IVANPOPOLAM
secret
```
Теперь, если злоумышленник добавит в запрос заголовок SOAPAction:
```
POST /service HTTP/1.1
Host: myHost
SOAPAction: "deleteAllUsers"
IVANPOPOLAM
secret
```
Шлюз, стоящий перед приложением пропустит такой запрос, т.к. он смотрит только в тело SOAP и в следствии приложение прочитав заголовок SOAPAction удалит всех пользователей.
**XXE** — классическая уязвимость, подробнее о ней — <https://habr.com/ru/company/vds/blog/454614/> тут. На самом деле XXE эксплуатируется похожим образом, как и XSS, выполняя вредоносный код на стороне сервера, при разведке данных на приложении и т.п.
Чем защищаться будем?
---------------------
Описанные ранее уязвимости в основном находятся на уровне логики работы парсеров и обработчиков запросов. Защита достигается путем взаимной работы отдела разработчиков и ИБ-отдела. И если со стороны разработчиков все понятно — не использовать уязвимые библиотеки и вовремя обновляться, то ИБ-отдел может предложить использовать средства защиты веб-приложений — WAF (Web Application Firewall) с функциональностью API Protect. В таком случае WAF обычно выступает дополнительной точкой отказа.
Статью я начал писать до февральских событий, и вообще хотел рассказать о Nginx App Protect и о его возможностях относительно уязвимостей. Поэтому я все равно расскажу, и в конце добавлю о российских решениях на рынке СЗИ.
### Чем может похвастаться Nginx App Protect
Во-первых, в отличии от классического WAF, он достаточно гибко разворачивается в DevOps инфраструктуру. Является модулем для подписки NGINX Plus.
Во-вторых, опять же в отличии от классического WAF, имеет более широкий пул сигнатур непосредственно для технологий, используемых во внутреннем взаимодействии компонентов веб-приложения.
Функционал:
1. Сигнатурный анализ. Автоматически или принудительно можно указать используемые технологии веб-приложения, и соответственно не «громоздить» сам nginx лишними проверками сигнатур. В общем для API обязательный функционал. Т.к. даже если злоумышленник не будет целиться непосредственно на библиотеки API, с помощью API вызовов вполне можно реализовать сценарий атаки на смежные технологии веб-приложения, передав злоумышленный пейлоад в API.
2. Подписка Threat Campaigns — это одна из ключевых фишек F5 и Nginx – тяжеловесные скореллированные сигнатуры с низким процентом ложных срабатываний, распространяются только по доп. подписке.
3. HTTP Compliance — не совсем относится к API, тем не менее ограничивающие политики для запросов всегда нужны и важны.
4. Data Guard — маскирование критических данных в запросах. Например, если в API передаются серия и номер паспорта, есть возможность маскировать эту информацию.
5. Parameter parsing — автоматический парсинг параметров из запроса для создания отдельных логических объектов. Далее созданные объекты могут быть индивидуально настроены для применения тех или иных ограничений.
6. JSON Content — в системе есть возможность создать логический профиль для описания разрешений при использовании JSON. Скажем, можно определить разрешенную длину полезной нагрузки JSON и длину массива, проверять возможные атаки на парсеры JSON.
7. XML Content — в системе реализован функционал защиты XML именно по сигнатурному анализу. Также, как и в случае с JSON, создается логический профиль для описания разрешенных условий передачи XML: максимально разрешенная глубина вложений, количество параметров, размер.
8. gRPC Content — в системе создается профиль содержимого gRPC. Nginx обнаруживает сигнатуры атак и запрещенные метасимволы. Кроме того, есть возможность запрещать использование неизвестных полей. Для этого необходимо будет указать файл определения языка (IDL).
Как и говорил ранее, немного о существующих решениях на российском рынке:
[PTAF](https://www.ptsecurity.com/ru-ru/products/af/) — разработка компании «Positive Technologies», не имеет каких-то автоматизированных протекторов API. Тем не менее у PTAF очень гибкий движок по написанию собственных правил, а также встроенные функции проверки потенциально нелегитимных JSON и XML файлов.
[Wallarm API Security](https://www.wallarm.com/) — продукт компании «Wallarm». Функционал направлен точечно на защиту API. Из коробки защищает по OWASP API TOP-10, имеет собственные API парсеры и протекторы JSON/XML.
[InfoWatch Attack Killer](https://www.infowatch.ru/products/attack-killer) — под капотом ядро «Wallarm», его API парсеры и механизмы защиты.
Фундаментально это все. Ограничения на точке отказа в любом случае не панацея, необходимо всегда анализировать уязвимые места парсеров и создавать виртуальные заплатки. Для этого во многих WAF реализован функционал создания своих сигнатур. Т.е., помимо того, чтобы просто внедрить WAF в свою инфраструктуру, необходимо постоянно его администрировать совместно с разработчиками веб-приложения. | https://habr.com/ru/post/670500/ | null | ru | null |
# Разбираем iPhone Core Data Recipes. Часть 2
#### **Introduction**
Данная статья, вторая и заключительная статья из серии «Разбираем iPhone Core Data Recipes». Первую часть статьи, вы можете прочитать [тут](http://habrahabr.ru/blogs/macosxdev/136319/). Цель серии статей — помочь начинающему iOS разработчику, понять, как правильно работать с SQLite базой данных используя Core Data на примере iPhone Core Data Recipes. В заключительной статье мы рассмотрим функционал добавления, редактирования и удаления записей из базы данных.
#### **Prerequisites**
Для самостоятельного изучения исходных текстов данного приложения, вам необходим стандартный набор инструментов:
* Mac OS X
* Xcode
Данный набор позволит вам просмотреть, изменить и запустить приложение на симуляторе. В случае же, если вы захотите попробовать запустить его на настоящем iPhone, требуется участие в iOS Developer Program.
А также, что немало важно, нужно базовое понимание структуры языка Objective-C и приложения.
Ссылки на используемые материалы и инструменты предоставлены в разделе References.
#### **How To Create a New Recipe**
Итак, первое что нам необходимо — это создать новый рецепт. За создание нового рецепта, в данном проекте, отвечает view controller — RecipeAddViewController. Рассмотрим его содержимое.
**RecipeAddViewController.h**
```
@protocol RecipeAddDelegate;
@class Recipe;
@interface RecipeAddViewController : UIViewController {
@private
//Объект Recipe, уже привязанный managedObjectContext
Recipe \*recipe;
//Поле для ввода названия рецепта
UITextField \*nameTextField;
id delegate;
}
@property(nonatomic, retain) Recipe \*recipe;
@property(nonatomic, retain) IBOutlet UITextField \*nameTextField;
@property(nonatomic, assign) id delegate;
//Сохраняем новый рецепт
- (void)save;
//Отменяем создание нового рецепта
- (void)cancel;
@end
@protocol RecipeAddDelegate
// recipe == nil on cancel
- (void)recipeAddViewController:(RecipeAddViewController \*)recipeAddViewController didAddRecipe:(Recipe \*)recipe;
@end
```
**RecipeAddViewController.m**
```
#import "RecipeAddViewController.h"
#import "Recipe.h"
@implementation RecipeAddViewController
@synthesize recipe;
@synthesize nameTextField;
@synthesize delegate;
- (void)viewDidLoad {
// Конфигурируем navigation bar
self.navigationItem.title = @"Add Recipe";
//Создаем кнопку Cancel и привязываем ее к действию cancel
UIBarButtonItem *cancelButtonItem = [[UIBarButtonItem alloc] initWithTitle:@"Cancel" style:UIBarButtonItemStyleBordered target:self action:@selector(cancel)];
self.navigationItem.leftBarButtonItem = cancelButtonItem;
[cancelButtonItem release];
//Создаем кнопку Save и привязываем ее к действию save
UIBarButtonItem *saveButtonItem = [[UIBarButtonItem alloc] initWithTitle:@"Save" style:UIBarButtonItemStyleDone target:self action:@selector(save)];
self.navigationItem.rightBarButtonItem = saveButtonItem;
[saveButtonItem release];
[nameTextField becomeFirstResponder];
}
...
//Сохраняем новый рецепт
- (void)save {
recipe.name = nameTextField.text;
NSError *error = nil;
if (![recipe.managedObjectContext save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
[self.delegate recipeAddViewController:self didAddRecipe:recipe];
}
//Отменяем создание нового рецепта
- (void)cancel {
[recipe.managedObjectContext deleteObject:recipe];
NSError *error = nil;
if (![recipe.managedObjectContext save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
[self.delegate recipeAddViewController:self didAddRecipe:nil];
}
//Т.к. проект не использует ARC, необходимо подчистить память
- (void)dealloc {
[recipe release];
[nameTextField release];
[super dealloc];
}
@end
```
В итоге, форма добавления нового рецепта, выглядит следующим образом
Детальное рассмотрение действий save & cancel будет ниже.
##### **Открываем форму создания нового рецепта**
Кнопка для создания нового рецепта расположена в главном окне нашего приложения (см. скриншот выше). Рассмотрим её более делатьно.
Данная кнопка создается в методе viewDidLoad контроллера RecipeListTableViewController.
```
UIBarButtonItem *addButtonItem = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemAdd target:self action:@selector(add:)];
self.navigationItem.rightBarButtonItem = addButtonItem;
[addButtonItem release];
```
К данной кнопке привязано действие add, которое также находится в контроллере RecipeListTableViewController (см. комментарии в исходном коде).
```
- (void)add:(id)sender {
//Создаем контроллер RecipeAddViewController который мы рассматривали выше
RecipeAddViewController *addController = [[RecipeAddViewController alloc] initWithNibName:@"RecipeAddView" bundle:nil];
//Связываем его с RecipeListTableViewController
addController.delegate = self;
//В managedObjectContext создаем объект Recipe с помощью NSEntityDescription, другими словами - создаем новую запись в таблице Recipe
Recipe *newRecipe = [NSEntityDescription insertNewObjectForEntityForName:@"Recipe" inManagedObjectContext:self.managedObjectContext];
//Передаем новый объект Recipe контроллеру RecipeAddViewController
addController.recipe = newRecipe;
//Модально оторбажаем контроллер RecipeAddViewController
UINavigationController *navigationController = [[UINavigationController alloc] initWithRootViewController:addController];
[self presentModalViewController:navigationController animated:YES];
[navigationController release];
[addController release];
}
```
После выполнения данного действия, откроется форма добавления нового рецепта рассмотренная выше. На этой форме, для пользователя доступно два действия — Save & Cancel.
###### **Сохраняем новый рецепт**
```
- (void)save {
//Свойству name объекта Recipe устанавливаем значение из поля
recipe.name = nameTextField.text;
NSError *error = nil;
//Сохраняем новую запись
if (![recipe.managedObjectContext save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
//Отображаем созданный рецепт с помощью RecipeDetailViewController (исходный текст для этого действия см. ниже в секции "Отображаем созданный рецепт")
[self.delegate recipeAddViewController:self didAddRecipe:recipe];
}
```
###### **Отменяем сохранение нового рецепта**
```
- (void)cancel {
//Удаляем ранее созданный объект Recipe, другими словами, удаляем ранее созданную запись в базе данных
[recipe.managedObjectContext deleteObject:recipe];
NSError *error = nil;
if (![recipe.managedObjectContext save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
//Отображаем список рецептов
[self.delegate recipeAddViewController:self didAddRecipe:nil];
}
```
###### **Отображаем созданный рецепт**
```
- (void)recipeAddViewController:(RecipeAddViewController *)recipeAddViewController didAddRecipe:(Recipe *)recipe {
if (recipe) {
// Если объект Recipe не равняется nil - тогда отображаем его
[self showRecipe:recipe animated:NO];
}
[self dismissModalViewControllerAnimated:YES];
}
- (void)showRecipe:(Recipe *)recipe animated:(BOOL)animated {
// Создаем контроллер который отображает детальную информацию о рецепте, передаем в него рецепт и отображаем
RecipeDetailViewController *detailViewController = [[RecipeDetailViewController alloc] initWithStyle:UITableViewStyleGrouped];
detailViewController.recipe = recipe;
[self.navigationController pushViewController:detailViewController animated:animated];
[detailViewController release];
}
```
#### **How To Create a New Ingredient**
Как вы можете видеть на скриншоте выше, при просмотре детальной информации о рецепте, в режиме редактирования, доступна ссылка «Add Ingredient». Создается она в методе
```
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
```
контроллера RecipeDetailViewController.
```
static NSString *AddIngredientCellIdentifier = @"AddIngredientCell";
cell = [tableView dequeueReusableCellWithIdentifier:AddIngredientCellIdentifier];
if (cell == nil) {
// Create a cell to display "Add Ingredient".
cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:AddIngredientCellIdentifier] autorelease];
cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator;
}
cell.textLabel.text = @"Add Ingredient";
```
За добавление и редактирование ингредиентов отвечает контроллер IngredientDetailViewController.
**IngredientDetailViewController.h**
```
@class Recipe, Ingredient, EditingTableViewCell;
@interface IngredientDetailViewController : UITableViewController {
@private
Recipe *recipe;
Ingredient *ingredient;
EditingTableViewCell *editingTableViewCell;
}
@property (nonatomic, retain) Recipe *recipe;
@property (nonatomic, retain) Ingredient *ingredient;
@property (nonatomic, assign) IBOutlet EditingTableViewCell *editingTableViewCell;
@end
```
**IngredientDetailViewController.m**
```
...
- (id)initWithStyle:(UITableViewStyle)style {
if (self = [super initWithStyle:style]) {
UINavigationItem *navigationItem = self.navigationItem;
navigationItem.title = @"Ingredient";
UIBarButtonItem *cancelButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemCancel target:self action:@selector(cancel:)];
self.navigationItem.leftBarButtonItem = cancelButton;
[cancelButton release];
UIBarButtonItem *saveButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemSave target:self action:@selector(save:)];
self.navigationItem.rightBarButtonItem = saveButton;
[saveButton release];
}
return self;
}
...
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}
...
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
//Отображаем только две строки, название и количество
return 2;
}
//Создаем поля для отображения и редактирования
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
static NSString *IngredientsCellIdentifier = @"IngredientsCell";
EditingTableViewCell *cell = (EditingTableViewCell *)[tableView dequeueReusableCellWithIdentifier:IngredientsCellIdentifier];
if (cell == nil) {
[[NSBundle mainBundle] loadNibNamed:@"EditingTableViewCell" owner:self options:nil];
cell = editingTableViewCell;
self.editingTableViewCell = nil;
}
if (indexPath.row == 0) {
cell.label.text = @"Ingredient";
cell.textField.text = ingredient.name;
cell.textField.placeholder = @"Name";
}
else if (indexPath.row == 1) {
cell.label.text = @"Amount";
cell.textField.text = ingredient.amount;
cell.textField.placeholder = @"Amount";
}
return cell;
}
...
- (void)save:(id)sender {
NSManagedObjectContext *context = [recipe managedObjectContext];
/*
Если объект ингредиента не создан - создаем и конфигурируем его
*/
if (!ingredient) {
self.ingredient = [NSEntityDescription insertNewObjectForEntityForName:@"Ingredient" inManagedObjectContext:context];
[recipe addIngredientsObject:ingredient];
ingredient.displayOrder = [NSNumber numberWithInteger:[recipe.ingredients count]];
}
/*
Обновляем объект ингредиента значениями из текстовых полей
*/
EditingTableViewCell *cell;
cell = (EditingTableViewCell *)[self.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
ingredient.name = cell.textField.text;
cell = (EditingTableViewCell *)[self.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
ingredient.amount = cell.textField.text;
/*
Сохраняем изменения
*/
NSError *error = nil;
if (![context save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
[self.navigationController popViewControllerAnimated:YES];
}
...
@end
```
Форма добавления ингредиента выглядит следующим образом
При нажатии на кнопку Save ингредиент будет сохранен в базе данных и отображен в списке. При нажатии на кнопку Cancel новый ингредиент сохранен не будет.
#### **How To Remove an Existing Recipe**
Контроллер RecipeListTableViewController содержит следующий код для поддержки удаления рецепта
```
- (void)viewDidLoad {
...
//Создаем кнопку Edit
self.navigationItem.leftBarButtonItem = self.editButtonItem;
...
}
...
// Включаем поддержку редактирования в UITableView
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
if (editingStyle == UITableViewCellEditingStyleDelete) {
// Удалем выделенный рецепт
NSManagedObjectContext *context = [fetchedResultsController managedObjectContext];
[context deleteObject:[fetchedResultsController objectAtIndexPath:indexPath]];
// Сохраняем изменения
NSError *error;
if (![context save:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
}
}
```
Теперь, при нажатии на кнопку Edit или выполнение жеста над UITableViewCell, UITableView перейдет в режим редактирования, что позволит вам удалить рецепт (см. скриншоты ниже).
При удалении рецепта, все связанные объекты (ингредиенты и картинка) в базе данных будут также удалены.
#### **How To Remove an Existing Ingredient**
В контроллере RecipeDetailViewController, все устроено аналогичным образом, за исключением добавления картинки (рассмотрено не будет).
```
- (UITableViewCellEditingStyle)tableView:(UITableView *)tableView editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath {
UITableViewCellEditingStyle style = UITableViewCellEditingStyleNone;
// Only allow editing in the ingredients section.
// В секции отображения ингредиентов, последняя строка добавляется автоматически (см. tableView:cellForRowAtIndexPath:), она требуется для добавления нового ингредиента, таким образом в списке ингредиентов включаем стиль удаления, а в последнем элементе стиль добавления
if (indexPath.section == INGREDIENTS_SECTION) {
if (indexPath.row == [recipe.ingredients count]) {
style = UITableViewCellEditingStyleInsert;
}
else {
style = UITableViewCellEditingStyleDelete;
}
}
return style;
}
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
// Только удаление и только в списке ингредиентов
if ((editingStyle == UITableViewCellEditingStyleDelete) && (indexPath.section == INGREDIENTS_SECTION)) {
// Удаляем ингредиент
Ingredient *ingredient = [ingredients objectAtIndex:indexPath.row];
[recipe removeIngredientsObject:ingredient];
[ingredients removeObject:ingredient];
NSManagedObjectContext *context = ingredient.managedObjectContext;
[context deleteObject:ingredient];
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationTop];
}
}
```
Форма добавления и удаления ингредиентов выглядит следующим образом
#### **Conclusion**
В данной статье, я специально не рассматривал создание картинки для рецепта — предполагая самостоятельное изучение читателем, данной функциональности (см. метод photoTapped контроллера RecipeDetailViewController). Приведенные примеры исходного кода, являются выдержками, изучить исходный код полностью, можно скачав проект (см. раздел References). Я надеюсь, что проделанная мной работа, по написанию этой серии статей, оказалась полезна для тебя — дорогой читатель! Всем спасибо за внимание и за проявленое терпение.
#### **References**
* [Mac OS X](http://www.apple.com/macosx/)
* [Xcode](http://developer.apple.com/xcode/)
* [iOS Developer Program](http://developer.apple.com/programs/ios/)
* [iOS Core Data](http://developer.apple.com/library/ios/#documentation/DataManagement/Conceptual/iPhoneCoreData01/Introduction/Introduction.html)
* [iPhone Core Data Recipes](https://developer.apple.com/library/ios/#samplecode/iPhoneCoreDataRecipes/Introduction/Intro.html#//apple_ref/doc/uid/DTS40008913) | https://habr.com/ru/post/136344/ | null | ru | null |
# Подключение GPRS-модема к Intel Edison
Эта статья объяснит, как создать сеть передачи данных с использованием протокола PPP, подключив [GPRS-модуль](http://www.seeedstudio.com/wiki/GPRS_Shield_V2.0) к плате Intel Edison.
Установка пакетов и включение PPP в ядре
----------------------------------------
Загрузим файлы с исходниками:
<http://downloadmirror.intel.com/24698/eng/edison-src-ww05-15.tgz>
Перед компиляцией исходных файлов, желательно увеличить root-раздел файловой системы. ([Инструкция по увеличению](https://communities.intel.com/docs/DOC-23449)).
В зависимости от конфигурации системы, постройка займет от 2 до 6 часов. Я использовал операционную систему Ubuntu 12.04.
Ошибки во время компиляции:
```
Install libtool using sudo apt-get install libtool.
1. ERROR: Task 535 (/home/inteldell/edison-src/device-software/meta-edison-distro/recipes-connectivity/libwebsockets/libwebsockets_1.23.bb, do_compile) failed with exit code '1'
2. NOTE: Tasks Summary: Attempted 1855 tasks of which 18 didn't need to be rerun and 1 failed.
```
Решение: замените строку 22 в recept файле:
```
edison-src/device-software/meta-edison-distro/recipes-connectivity/libwebsockets/libwebsockets_1.23.bb
```
Оригинал:
```
export OPENSSL_CONF=${TMPDIR}/sysroots/x86_64-linux/usr/lib/ssl/openssl.cnf
```
Заменить на:
```
export OPENSSL_CONF=${TMPDIR}/sysroots/i686-linux/usr/lib/ssl/openssl.cnf
```
Конфигурирование PPP в ядре.
```
# bitbake virtual/kernel –c menuconfig
```
Сначала, я включил только поддержку PPP для асинхронного последовательного порта, но в результате появилась другая ошибка – включил PPP фильтрацию. В конце концов, я включил всё.
Теперь устанавливаем пакеты PPP из <http://repo.opkg.net/edison/repo/core2-32/>
Демон pppd используется для соединения GPRS-модуля.
После удачной установки вы должны увидеть следующую файловую структуру.
Чтобы работать с модемом, аппаратный последовательный порт должен быть подключен к GPIO 0 и 1.
Включение последовательного порта
---------------------------------
Включите последовательный порт на пинах 0 и 1, выполнив следующие команды в терминале:
```
echo 214 > /sys/class/gpio/export 2>&1
echo high > /sys/class/gpio/gpio214/direction
echo low > /sys/class/gpio/gpio214/direction
echo 131 > /sys/class/gpio/export 2>&1
echo mode1 > /sys/kernel/debug/gpio_debug/gpio131/current_pinmux
echo 249 > /sys/class/gpio/export 2>&1
echo high > /sys/class/gpio/gpio249/direction
echo 1 > /sys/class/gpio/gpio249/value
echo 217 > /sys/class/gpio/export 2>&1
echo high > /sys/class/gpio/gpio217/direction
echo 1 > /sys/class/gpio/gpio217/value
echo out > /sys/class/gpio/gpio131/direction
echo 0 > /sys/class/gpio/gpio131/value
echo 130 > /sys/class/gpio/export 2>&1
echo mode1 > /sys/kernel/debug/gpio_debug/gpio130/current_pinmux
echo 248 > /sys/class/gpio/export 2>&1
echo low > /sys/class/gpio/gpio248/direction
echo 0 > /sys/class/gpio/gpio248/value
echo 216 > /sys/class/gpio/export 2>&1
echo in > /sys/class/gpio/gpio216/direction
echo in > /sys/class/gpio/gpio130/direction
echo high > /sys/class/gpio/gpio214/direction
```
Тестирование GPRS-модуля
------------------------
Использовалась рабочая SIM-карта от оператора T-Mobile. Проверим состояние GPRS-модема, посылая AT-команды через программу microcom:
```
# microcom /dev/ttyMFD1 –s 115200
AT
OK
AT+CMGF=1 Set SMS text format
OK
AT+CMGS="+1503*****79" Send SMS message
> Hello World
+CMGS: 14
OK
```
Тоже самое может быть сделано программированием последовательного порта или с использованием библиотеки [mraa](http://iotdk.intel.com/docs/master/mraa/uart_8h.html).
Включение GPRS:
```
AT+CGATT=1 attach to GPRS network (normally includes in atd*99#)
AT+CGATT? should return +CGATT: 1
AT+CGDCONT=1,"IP","epc.tmobile.com" context definition (for T-Mobile)
AT+CGACT=1 PDP context activation
AT+CGDATA="PPP",1 enter data mode
```
Подключение к интернету с использованием GPRS
---------------------------------------------
Создайте скрипт, который определяет контекст PDP (Packet Data Protocol) и сообщает о соединении. Необходимые скрипты есть в файле ppp.zip, ссылка на который приведена в конце статьи.
Теперь создайте соединение, использую команду:
```
# pppd call gprs &
```
Вы можете проверить лог-файл следующей командой:
```
#cat /var/log/ppp/log
Press CTRL-C to close the connection at any stage!
defining PDP context...
AT
OK
ATH
OK
ATE1
OK
AT+CGDCONT=1,"IP","epc.tmobile.com","",0,0
OK
waiting for connect...
ATD*99#
CONNECT
Connected.
Serial connection established.
Using interface ppp0
Connect: ppp0 <--> /dev/ttyMFD1
not replacing default route to wlan0 [192.168.1.1]
local IP address 100.198.64.64
remote IP address 192.200.1.21
primary DNS address 10.177.0.34
secondary DNS address 10.168.185.116
```
Файл для скачивания:
[ppp.zip](https://software.intel.com/sites/default/files/managed/e2/cb/ppp.zip)
Ссылки:
-------
[communities.intel.com/docs/DOC-23449](https://communities.intel.com/docs/DOC-23449)
[repo.opkg.net/edison/repo/core2-32](http://repo.opkg.net/edison/repo/core2-32/)
[communities.intel.com/thread/54236](https://communities.intel.com/thread/54236)
[communities.intel.com/thread/55790](https://communities.intel.com/thread/55790)
[downloadmirror.intel.com/24698/eng/edison-src-ww05-15.tgz](http://downloadmirror.intel.com/24698/eng/edison-src-ww05-15.tgz)
[www.att.com/esupport/article.jsp?sid=36059&cv=820#fbid=AcRge45P9Za](http://www.att.com/esupport/article.jsp?sid=36059&cv=820#fbid=AcRge45P9Za)
[wiki.openmoko.org/wiki/T-Mobile\_pppd\_scripts](http://wiki.openmoko.org/wiki/T-Mobile_pppd_scripts)
[www.tldp.org/HOWTO/PPP-HOWTO](http://www.tldp.org/HOWTO/PPP-HOWTO/) | https://habr.com/ru/post/383075/ | null | ru | null |
# Работа распределённой команды в условиях самоизоляции: как мы почти не заметили разницы
Режим самоизоляции многих вынудил работать из дома. Кому-то смена обстановки даётся легче, кому-то сложнее, а кто-то и вовсе не заметил бы разницы, но после объявления недели (а потом и месяца) «карантина» прирост постов о лайфхаках, эффективности и продуктивности в ленте существенно увеличился.
Меня зовут Михаил Трошев, я руковожу службой поисковых интерфейсов Яндекса. Наша команда много лет работает распределённо — ниже расскажу, чем это отличается, а чем схоже с «удалённо», как организовано, почему не ломается и чем может быть полезен наш опыт тем, кого резкая смена режима работы застала врасплох.
Что-то наверняка покажется вам банальным (Agile, Scrum, Kanban, DevOps — ничего себе открытия!), но это ведь как с зарядкой по утрам: все знают, что она полезна, но делать регулярно и в полную силу почему-то лень. Так вот: мы делаем. И это работает.
### Не удалённо, а распределённо
Как это выглядит: 90 фронтендеров каждый день собираются в офисах Москвы, Питера, Казани, Иннополиса, Екатеринбурга, Симферополя и Минска — нетрудно заметить, что нас разделяют не только расстояния, но и часовые пояса. Однако и это ещё не всё: фронтендеры распределены между продуктовыми командами (virtual teams) примерно по трое-семеро + бэкендеры, дизайнеры, тестировщики и менеджеры (в 2019 году подробно рассказал про наши рабочие структуры [здесь](https://www.youtube.com/watch?v=q7xJ7EZeXrA)). То есть практически все участники одной такой команды находятся в разных городах. Не совсем удалёнка, но очень близко к этому: хотя несколько коллег рядом всё-таки есть, возможности микросинхронизации с остальными существенно ограничены по сравнению с работой в опенспейсе.
Приходится применять асинхронные средства связи с большой задержкой реакции. Чем сильнее команда распылена между разными офисами, тем больше в повседневном рабочем взаимодействии накладных расходов на ожидание, которые могут похоронить любой проект. Чтобы сэкономить время:
— жизненный цикл каждой задачи от идеи до продакшна устроен максимально консистентно: процедуры, статусы, переход между этапами — формализовано всё, что только можно (примерно 90% задач). При этом мы стараемся сохранить бюрократию простой и понятной, иначе она перестает быть полезной и начинает мешать;
— вся команда в курсе правил, регулирующих рабочий процесс, и старается чётко им следовать; рутину стараемся автоматизировать. Таким образом каждый занят своим делом и не тратит время на принятие однотипных микрорешений: программисты — программируют, менеджеры продукта придумывают продуктовые фичи, дизайнеры — дизайнерят.
Ничего нового, правда? Однако этот нехитрый подход очень выручил нас в условиях самоизоляции: каждый сотрудник может принести максимум пользы самостоятельно, поскольку в курсе достаточных для работы подробностей.
Но обо всём по порядку.
### Этап 0. Планирование
У каждой команды есть беклог, верхушка которого оценена и приоритизирована:
Принципиальный момент — каждый участник команды должен понимать: эту задачу нужно делать, потому что она привязана к эпику, эпик привязан к цели, а цель важная. Иначе либо люди могут начать делать не то что нужно, либо менеджер будет вынужден постоянно всех контролировать и тушить пожары. Последнее, кстати, бывает сложно заметить в офисе, но невозможно пропустить на удалёнке: кругом неразбериха, работа стоит, в мессенджере заводится десяток чатиков в попытках синхронизироваться — в итоге вся команда переписывается в чате, вместо того чтобы писать код. Критически важно организовать планирование в команде таким образом, чтобы каждый участник процесса понимал, что и в каком порядке ему нужно делать. Тогда и руководитель команды сможет сосредоточиться на продукте, не отвлекаясь на постоянные мелкие вопросы.
Конечно, детализировать весь беклог до дна невозможно, но качественная проработка его верхушки позволяет быстро набирать новые задачи в спринт — почти все команды живут двухнедельными спринтами — и поддерживать запас для следующего. При таком подходе опытная команда может набрать спринт даже без менеджера, если он вдруг оказался недоступен.
Чтобы не растягивать время работы над задачей, команда занимается «полезной бюрократией»: менеджер формулирует чёткое описание, исполнители проставляют правильные статусы, задачи «перетекают» слева направо на спринтовой борде:
Здесь вся команда видит полную и актуальную картину по спринту. Если кто-то заболел, ушёл на дежурство или в отпуск, другие участники сразу подхватывают задачи в их текущем статусе.
Ну и как же без ежедневных синков, когда формальной организации процесса недостаточно, чтобы разрулить какие-то частные случаи, и бюрократия начинает скорее мешать процессу. Обычно детализации задач статусами (open > in progress > in review > ready for test > testing > tested > ready for dev > dev > rc > closed) бывает достаточно, но в 10% случаев требуется что-то уточнить, проговорить словами, объяснить «на пальцах». Кстати, я убеждён, что все рабочие встречи (в том числе стендапы) нужно обязательно проводить с использованием видеосвязи, а не только голосом, потому что это заставляет привести себя в порядок и настроиться на работу.
Очень важно, чтобы на синке присутствовала вся команда: быстро сверили контекст, разобрали задачи и начали работать, ориентируясь по борде, не теряя больше времени на вопросы друг другу. Рабочие чаты у нас, конечно, тоже есть, но мы стараемся не флудить в них и использовать для получения быстрого (в идеале бинарного) ответа: можно ли катить релиз, где найти инструкцию, с кем обсудить API источника данных.
**Где выиграли время: синхронизация, принятие микрорешений**
### Этап 1. Разработка: open > in progress
«Open» — задача ждёт исполнителя. Разработчики забирают их так, чтобы каждая была готова максимально быстро. Например, бывает, что на дворе пятница, а разработчик на следующей неделе уходит на дежурство (и это известно заранее, за месяц). В этом случае ему лучше взять мелкую задачу, чтобы успеть сделать её за один день: стараемся не передавать начатое. Если кто-то не успевает довести работу до конца, лучше влить как есть, а потом отдельным пул-реквестом добить остатки.
Развернул локальную рабочую копию проекта — не забудь перевести задачу из «open» в «in progress», чтобы за неё не взялся кто-то другой. «Локальная», кстати, ключевое слово — работать можно откуда угодно, качество интернет-соединения не будет блокирующим фактором. Сейчас, когда инфраструктура и сети перегружены, очень актуально. Наш локальный сервер для разработки позволяет использовать дампы данных — zip-архивы с данными по разным запросам, чтобы можно было полноценно работать совсем без интернета. После того как разработчик закончил работу и отправил пул-реквест, включается автоматизация.
**Где выиграли время: самостоятельная оценка сил и возможностей, не всегда требуется превозмогать нестабильное интернет-соединение**
### Этап 2. Автоматические проверки: in progress > in review
Перед тем как задача уйдёт в ревью, она проходит проверки на качество кода, производительность, отсутствие визуальных и функциональных багов. Тут можно было бы много написать о полноте и разнообразии наших автоматических проверок, но, во-первых, это тянет на несколько отдельных рассказов, а во-вторых, выходит далеко за рамки обсуждаемой темы. Я просто дам ссылки на описание инструментов:
— стандартный набор инструментов статического анализа: [ESLint](https://eslint.org/) и [Stylelint](https://stylelint.io/) с богатым набором плагинов;
— наши собственные статические проверки: наличие и качество переводов, валидация yaml-файлов;
— стандартные инструменты для модульного тестирования: [Mocha](https://mochajs.org/), [Karma](https://karma-runner.github.io/latest/index.html), [PhantomJS](https://phantomjs.org/), [Istanbul](https://istanbul.js.org/);
наш собственный инструмент для функционального и визуального тестирования — [Hermione](https://yandex.ru/dev/hermione/);
— Pulse — для тестирования производительности — тоже наш собственный. Упоминали о нём вот [тут](https://youtu.be/TzCMDlYMydA?t=419).
Кстати, сюда же откатится задача в случае возникновения проблем на любом из этапов — к сожалению, даже самое тщательное планирование не спасает от ошибок на 100%, что-то может пойти не так. Обнаруживший призывает в задачу нужного человека, описывает суть проблемы, загружает скриншоты или даже видео, может дополнительно написать в чат команды, чтобы все заметили, что задача застопорилась. Что бы это ни было — баг при тестировании вылез, дизайн поменялся, не хватило данных от бэкенда.
**Где выиграли время: фильтрация ошибок — разработчик может обнаружить их без привлечения коллег, меньше паники если что-то пошло не так — очевидный первый шаг**
### Этап 3. Код-ревью: in review > ready for test
Во-первых, призвать в пул-реквест хочется не просто свободного ревьюера, а человека, который понимает, что происходит в твоём коде; во-вторых, из смежной команды, чтобы вся служба имела представление, кто чем занимается — всё это прописано в нашем регламенте. Даже в маленьком офисе бывает сложно и долго организовывать это вручную, что уж говорить про распределёнку (и самоизоляцию!). На помощь приходит автоматизированная код-ревьюшница: статусы она тоже меняет самостоятельно. Подробно останавливаться на том, как она работает, не буду — лучше послушать [рассказ](https://www.youtube.com/watch?v=oEjPmLJSQxg) разработчика. Ещё она умеет пинговать исполнителей: чем дольше задача висит в ревью, тем яростнее пингует.
**Где выиграли время: поиск релевантного ревьюера, напоминания обработать пул-реквест**
### Этап 4. Тестирование: testing > tested
Когда изменение прошло код-ревью, запускаем автотесты. Только после того как все они станут зелёными, задача передаётся на ручное тестирование. Важно, что за задачу, пока её явно не передали кому-то ещё, всегда отвечает исполнитель — именно он должен побыстрее протащить свой код через код-ревью и тестирование до продакшена. То есть мы всегда знаем, кто крайний, каждый постоянно мониторит не только свои задачи, но и всё происходящее в команде. Тестировщик в команде обычно один, и ему это тоже удобно: он видит, что прилетит следующим, может эффективнее использовать своё время.
Тестировщик может:
— отдать задачу на тестирование асессорам — [пост](https://habr.com/ru/company/jugru/blog/425247/) со всеми подробностями. По итогам тестирования асессорами что-то может потребовать исследовательского тестирования или перепроверки;
— сам протестировать задачу на живом девайсе или используя ферму устройств с удалённым доступом — Колхоз.
Живые девайсы находятся в [Гиперкубах](https://habr.com/ru/company/yandex/blog/485050/) в каждом офисе Яндекса. Любой сотрудник может взять необходимое ему устройство с нужными характеристиками, предварительно выбрав ближайшую точку со свободным устройством. В норме через некоторое время система автоматически напомнит, что девайс пора вернуть, но на время самоизоляции эту функцию отключили. Дежурная команда отследила, чтобы живые устройства достались тем, кому это критически необходимо, а всем остальным, чтобы не тормозить рабочие процессы, помогли с подключением к Колхозу.
Колхоз — ферма устройств для удалённого тестирования, воспользоваться которой может любой сотрудник. Android, iOS — мы проверяем изменения даже на самых старых, сложных в поддержке версиях систем, чтобы наши сервисы были доступны любому. Но и флагманы тоже стараемся заполучить как можно скорее и в Колхоз, и в Гиперкубы. Помните «шторку» (она же «монобровь»), которая появилась у девятого iPhone, и все связанные с ней проблемы?
**Где выиграли время: планирование, автотесты, распределение устройств: доступны даже при самоизоляции**
### Этап 5. Вливание: ready for fev > dev
Задача протестирована — пора влить её в общую ветку.
> N.B. исторически так сложилось, что конкретно в нашем проекте общая ветка называется не `master` или `trunk`, а `dev`. Отсюда и название статусов задач в [Трекере](https://yandex.ru/tracker/). Но далее для простоты я буду называть общую ветку `trunk`.
Когда вливаний много (у нас, например, больше 30 влитых пул-реквестов в день), возникают две проблемы:
— **минорная**: история в git, если вливаться как попало и не делать rebase, становится очень запутанной, а если нашёлся какой-то баг, откатиться назад очень сложно;
— **критичная**: интеграционное тестирование. Не всегда физически возможно дождаться окончания тестирования своих изменений вместе с последней версией trunk, поэтому может случиться следующее: два пул-реквеста, каждый из которых по отдельности ничего не ломает, после вливания сломают trunk. Чтобы предотвратить подобное, мы придерживаемся [Trunk based development](https://trunkbaseddevelopment.com/), то есть релиз можно выкатить от любого коммита. И хотя мы ещё не пришли окончательно к Continuous Deployment, trunk у нас «зелёный». И ломать его даже раз в неделю для нас категорически неприемлемо.
Уже несколько лет мы используем инструмент Merge Queue для автоматизации очереди и постоянно совершенствуем его. Изменения вливает не разработчик, а робот. В каждом пул-реквесте делает rebase по свежей версии trunk и запускает полный набор тестов. Это довольно длительный процесс, поэтому на живых людях построить его невозможно — человек просто не дождётся окончательных результатов. А робот трудится без сна, отдыха и выходных. Более того, задачу может поставить в очередь не сам разработчик, а тестировщик сразу после окончания тестирования, это лишний раз позволяет сэкономить время.
[Подробнее](https://www.youtube.com/watch?v=eRlEJjyJgVU) о Merge Queue.
**Где выиграли время: предотвращаем блокирующие поломки, не надо вручную контролировать вливание пул-реквеста**
### Этап 6. Релиз: rc > closed
Каждый рабочий день в 5 утра от последнего коммита в trunk у нас автоматически отводится новый релиз: сборка статического и динамического пакетов, выкладка на prestable, тестирование асессорами. Дальше дежурный тестировщик просматривает отчёт и, если есть баги, сообщает о них дежурному разработчику. А если всё хорошо, передаёт дежурному менеджеру. Если тот даёт добро, дежурный разработчик выкатывает релиз.
Тут важно уточнить, что в релиз попадают задачи разных команд, поэтому всем выгодно, когда на релизы явно выделен один дежурный разработчик, который целую неделю только и занимается тем, что катает релизы и следит за мониторингами ошибок. Это позволяет остальным разработчикам проекта как можно раньше (фактически сразу после отправки в Merge Queue) переключаться на новые задачи.
Обычно вся релизная деятельность происходит в рабочее время (даже из дома мы просим всех соблюдать режим — в итоге все нарушают его в разную сторону, но мы не прекращаем пытаться), но если что-то не так в продакшне, дежурная смена разбудит дежурного разработчика, чтобы тот оперативно отреагировал.
Напоминаю, основная задача — сократить время синхронизации участников команды друг с другом и количество рутины: все в курсе, кто на дежурстве. Все знают, что и как надо делать, у всех есть инструкции. Когда менеджер разрешит выкатывать релиз, он не будет объяснять разработчику порядок действий, разработчик сам всё знает и умеет.
**Где выиграли время: синхронизация, принятие микрорешений
Цикл замкнулся.**
Распределённая работа — прививка от плохих, неэффективных процессов, тормозящих проекты даже в привычных условиях, что уж говорить о нестандартных. Опыт нашей команды подтверждает: если с должным занудством подойти к настройке процедур и взаимодействий и по-честному соблюдать все правила, какими бы банальными они ни казались, рабочий процесс будет довольно сложно парализовать.
Чем-то напоминает организацию дорожного движения: когда автомобилей было мало и они были медленными, о ПДД мало кто задумывался. Сейчас автомобилей очень много и они быстрые — движение без правил стало невозможным. Чем лучше (и одновременно проще) сформулированы эти правила, чем тщательнее их выполняют участники движения, тем выше пропускная способность дорог.
Спасибо, что дочитали до конца. До встречи в комментариях! | https://habr.com/ru/post/500116/ | null | ru | null |
# Vector Drawable API. Возможности применения
2014 год был особенным для всех, кто занимается разработкой под Android — он принес одно из самых значимых обновлений Android за всю его историю, версию Android 5.0. С этим обновлением мы получили новый визуальный язык, детальные гайдлайны, множество новых API и инструментов. И, как всегда в случае таких массивных обновлений, не все новшества сразу пробивают себе дорогу в реальные проекты. Где-то мешает инерция мышления разработчиков, привыкших решать определенные задачи определенным образом, где-то — отсутствие документации по новым API, где-то — отсутствие поддержки новых возможностей на старых версиях платформы. Но время не стоит на месте и благодаря труду команды Android, а также независимых разработчиков, такие API постепенно обретают обратную поддержку. И сегодня я хочу рассказать об API векторной графики Android, который способен серьезно облегчить жизнь разработчика, но при этом до сих пор не пользуется популярностью.
**Немного матчасти**Компьютерная графика оперирует двумя типами файлов — растровым и векторным. Растровые файлы представляют собой набор матриц, каждая ячейка в которой описывает один участок изображения, один его пиксель. Векторные файлы содержат набор примитивных фигур и команд, позволяющих по заданным координатам построить ту или иную форму. Различия во внутренней структуре файлов растровой и векторной графики отражаются в поведении различных типов компьютерной графики при различных сценариях использования. Так растровые файлы очень плохо масштабируются, особенно в большую сторону, — в исходном файле просто отсутствует информация для заполнения изображения большей площади. Также у растровых форматов существует прямая зависимость между физическим размером изображения и размером файла на диске. В свою очередь, объект в файле векторного формата может иметь только одну заливку, поэтому для создания фотореалистичного изображения необходимо создать множество объектов для отображения бликов, теней, текстур, что, во-первых требует большого труда иллюстратора, а во-вторых оказывает нагрузку на устройство рендеринга.
Неудивительно, что за 30 лет существования систем настольного издательства сложилось некое «разделение труда», когда растровые форматы используются для фотоизображений, а векторные — для простой графики, шрифтов, логотипов.
### Material Design и векторная графика
Как же мы можем использовать поддержку векторной графики, появившуюся с выходом Android 5.0? Для ответа на этот вопрос необходимо рассмотреть Material Design не просто как новый стиль оформления Android, а как часть более общего тренда в дизайне интерфейсов, начало которому было положено с выходом интерфейса Metro в Windows 8. Затем был Flat Design в iOS 7 и Material Design в Android. Ключевыми характеристиками этого стиля, истоки которого можно искать в работах представителей школы [Баухаус](https://ru.wikipedia.org/wiki/Баухауз), а также в направлении т.н. [швейцарской школы типографики](https://ru.wikipedia.org/wiki/Интернациональный_типографический_стиль), являются отказ от скефоморфизма, использование простых и выразительных цветов, четкая структура верстки.
Благодаря этому можно избавиться от использования огромного количества фотографических текстур, перейти к использованию в интерфейсе простой векторной графики. Достаточно взглянуть на иконографию Material Design для того, чтобы убедиться, что в иконках отныне нет места фотореалистичной трехмерности, бликам и градиентам, иконка в Material Design — это выразительная фигура, с четкими границами и плоской заливкой. Благодаря этому мы можем использовать для иконок векторную графику.
Переход на векторный формат изображений дает нам ряд преимуществ: нам не нужно нарезать набор иконок под все разрешения экрана, не нужно перерезать его заново в случае каких-то изменений, дополнительно необходимо отметить снижение размера установочного пакета с приложением, а также снижение нагрузки на оперативную память, требуемую для загрузки текстур и иконок в png. Некоторое время назад в техническом блоге Instagram появилась статья, где инженеры сервиса описывали процесс редизайна приложения по гайдам Material Design. [По их данным](http://instagram-engineering.tumblr.com/post/97740520316/betterandroid) переход на Material Design и, сопутствующее ему, «уплощение интерфейса» позволили сократить время запуска приложения на 120 мс.
Надеюсь, после таких аргументов вы захотели использовать векторную графику и сейчас я перейду к детальному разбору структуры API и методов работы с ним.
### Класс VectorDrawable
##### Тэг Vector
Основой API векторной графики в Android является класс [`VectorDrawable`](https://developer.android.com/reference/android/graphics/drawable/VectorDrawable.html). Объекты этого класса являются ресурсами и описываются при помощи языка XML, размещаются они в директории `res/drawable` нашего проекта. Корневым элементом класса является тэг `vector`. У тэга `vector` есть несколько атрибутов, обязательными являются две группы атрибутов, которые определяют размер изображения нашего `drawable`. Я говорю об атрибутах `width` и `height` — они указываются с использованием неких единиц измерения (набор их стандартен для Android — `dp`, `sp` и `px`), а также `viewportWidth` и `viewportHeight` — они указываются без единиц измерения. При помощи `width` и `height` мы можем указать физический размер, который займет наш `drawable` на экране, а `viewport` можно сравнить с окошком, через которое мы смотрим на наше изображение. Размеры `viewport` могут как совпадать, так и отличаться от размеров изображения. При этом, изменяя размер `viewport`, мы можем изменять площадь занимаемую фигурой внутри `drawable`.
Стоит отметить, что у `viewport` отсутствует возможность задать координат `pivotPoint` и изменения размеров `viewport` будут отсчитываться от левого верхнего угла. Также у элемента `vector` есть ряд других атрибутов, смысл которых ясен из названия.
```
```
##### Элемент Path
Главное, без чего не может обойтись ни один файл VectorDrawable — это тэг `Path`. У элемента `Path` самый главный атрибут — это атрибут `pathData`. Его значением является строка символов, разделенных запятыми. Эти символы не что иное, как команды формата SVG.
```
```
[SVG](https://ru.wikipedia.org/wiki/SVG) — это формат векторной графики, разработаннный специально для интернета, и он поддерживается всеми современными браузерами, а также экспорт в SVG доступен из большинства графических редакторов. SVG поддерживает набор примитивных фигур, таких как овал, прямоугольник, спираль и пр., а также фигуры произвольной формы. Фигуры произвольной формы описываются при помощи набора команд, которые представляют из себя координаты точек и отрезков прямых, кривых Безье и дуг, их соединяющих. Выполнив последовательно эти команды возможно построить требуемую нам фигуру.
Поскольку для описания файлов SVG также используется язык XML, мы можем открыть его в текстовом редакторе и найти объект `Path`. У этого объекта будет присутствовать атрибут `d`, значением которого будет строка с командами, идентичными тем, что мы можем найти в качестве значения атрибута `pathData` объекта `Path` в ресурсе VectorDrawable. Это обстоятельство позволяет нам легко создавать ресурсы VectorDrawable — для этого достаточно скопировать набор команд из файла в формате SVG в наш ресурс VectorDrawable.
```
```
Для того, чтобы мы могли увидеть нашу фигуру мы должны ей назначить заливку и, опционально, обводку. Делается это при помощи атрибутов fillColor, strokeColor, strokeWidth. Стоит отметить, что, в отличие от SVG, фигура в VectorDrawable не может иметь градиентную заливку — только определенный цвет.
```
```
##### Элемент Group
Самый простой векторный файл содержит только одну фигуру, однако в сложных изображениях количество таких фигур может исчисляться десятками. Для удобства работы с ними отдельные фигуры можно объединять в группы, используя элемент `Group`. Возможность объединять несколько объектов Path в группу позволяет не только упорядочить структуру нашего drawable-ресурса, но и дает возможность применить групповые настройки к набору объектов, но самое главное, что группа может использоваться для анимации, о чем мы поговорим далее.
Таким образом, в одном ресурсе VectorDrawable мы можем создавать сложную графику, используя различные объекты `Path`, которым можно задавать свой собственный цвет, прозрачность, обводку, указывать положение на экране. Объекты `Path` можно объединять в группы, для которых опять же можно указывать ряд групповых атрибутов. Самое интересное, что все атрибуты можно заанимировать, при этом для применения одной анимации к набору объектов `Path`, удобно эти объекты объединить в группу.
```
```
### Класс AnimatedVectorDrawable
Второй частью API векторной графики, появившегося в Android Lollipop, является класс [`AnimatedVectorDrawable`](https://developer.android.com/reference/android/graphics/drawable/AnimatedVectorDrawable.html), который позволяет создавать анимации для классов VectorDrawable. AnimatedVectorDrawable представляет собой расширение PropertyAnimation, которая дает нам возможность создания анимаций, основанных на изменении значений любых атрибутов объекта. Файлы AnimatedVectorDrawable тоже относятся к ресурсам приложения и создаются с использованием XML. Корневым элементом ресурса векторной анимации является тэг `animated` — vector. У этого тэга только один атрибут `drawable`, в котором мы указываем имя ресурса VectorDrawable, для которого мы хотим создать анимацию.
Внутри элемента `animated-vector` располагаются объекты `target`, которые представляют собой цели для анимаций. Наиболее замечательным является то, что `animated-vector` может содержать более одного `target`. Этот факт дает возможность создавать сложные анимации, позволяя анимировать различные части изображения при помощи различных анимаций, создавая комплексные анимации.
```
```
В частности знаменитая анимация hamburger-to-arrow, так очаровавшая всех в момент анонса Android 5.0, легко создается с использованием векторной анимации: верхняя и нижняя полосочки гамбургера движутся навстречу средней, одновременно с этим вся группа вращается на 180° — здесь мы указываем три `target` и создаем для них три анимации.
У элемента `target` есть два главных атрибута — `name`, в котором мы указываем имя объекта `Path` или объекта `Group`, который будет анимироваться, и `animation`, куда мы передаем ссылку на ресурс анимации, размещаемый в папке `res/anim`.
```
```
Ресурс анимации это стандартный `animator-set`, c объектом `objectAnimator` внутри. В качестве значения атрибута `propertyName` мы можем указать любой атрибут объекта `Path` или `Group` из VectorDrawable. В зависимости от типа атрибута мы должны указать соответствующий тип значений в атрибуте `valueType`.
Android Lollipop с появлением нового типа графики принес и новый тип `property`, для которого можно создать анимацию — это анимация значения атрибута `pathData` у объекта `Path`. Для этого в поле `propertyName` появилось новое значение `pathData` и соответствующее ему значение `valueType` — `pathType`. При этом старые поля `valueFrom` и `valueTo` принимают в качестве аргументов две строки с наборами команд, описывающие соответственно начальную и конечную форму фигуры. Благодаря этому новому типу анимаций можно создавать сложные анимации, преобразующие форму фигуры, ранее недоступные в Android — например анимации морфинга, преобразующие кнопку Play в кнопку Pause. Сам Google рекомендует сохранять данные с командами path в строковых ресурсах.
Стоит заметить, что для успешной работы анимации количество команд и тип команд в исходном и конечном пути должно быть одинаковым. В противном случае вы получите исключение времени выполнения. Данное суровое условие в свое время отняло у меня много времени, но недавно появился инструмент [VectAlign](https://github.com/bonnyfone/vectalign), позволяющий автоматически выровнять две строки с путями по числу и типу команд.
### Запуск анимации
Файлы с векторной анимацией реализуют интерфейс [`Animatable`](https://developer.android.com/reference/android/graphics/drawable/Animatable.html) и для запуска анимации, мы запрашиваем `Drawable`, приводим его к `Animatable` и вызываем метод `start()`.
```
((Animatable) imageView.getBackground()).start();
```
Интерфейс `Animatable` крайне прост — в нем только три метода: `isRunning()`, `start()`, `stop()`. Таким образом отсутствует возможность задания [`AnimationListener`](https://developer.android.com/reference/android/view/animation/Animation.AnimationListener.html). Также отсутствует возможность передать нашу векторную анимацию в [`AnimatorSet`.](https://developer.android.com/reference/android/view/animation/AnimationSet.html) Поэтому прямая возможность создавать хореографию анимаций, или запускать какие-то действия по завершению анимации отсутствует. Точнее, отсутствовала — в 23 версии Android SDK интерфейс `Animatable` был расширен новым интерфейсом [`Animatable2`](https://developer.android.com/reference/android/graphics/drawable/Animatable2.html), который позволяет для нашей векторной анимации регистрировать [`AnimationCallback`](https://developer.android.com/reference/android/graphics/drawable/Animatable2.AnimationCallback.html).
Для версий до 23 для хореографии можно использовать возможности отложенного запуска, например при помощи метода `Handler.postDelayed()`.
### Обратная поддержка
Возвращаясь к тому, с чего я начал, хочу напомнить, что внедрению векторной графики в проектах до сих пор мешало отсутствие обратной поддержки этого функционала на версиях Android < 5.0. Однако, время не стоит на месте и, хотя официальная поддержка векторных форматов на старых версиях платформы отсутствует, благодаря независимым разработчикам появляются библиотеки, дающие возможность использования VectorDrawable на устройствах с API >= 14. И я говорю о библиотеках [VectorCompat](https://github.com/wnafee/vector-compat) и [BetterVectorDrawable](https://github.com/a-student/BetterVectorDrawable). Сам я имею опыт работы только с библиотекой VectorCompat, поэтому буду говорить только о ней. Интересующихся тонкостями работы с BetterVectorDrawable отсылаю к циклу статей [astudent](https://habrahabr.ru/users/astudent/): [часть 1](http://habrahabr.ru/post/265601/), [часть 2](http://habrahabr.ru/post/265603/);
Для того, чтобы ресурсы с векторной графикой работали через библиотеку обратной совмести, нам необходимо выполнить ряд условий. Во-первых, в ресурсах XML, которые описывают наши VectorDrawable и анимации для них, необходимо продублировать ряд атрибутов, таких как, `viewportHeight, viewportWidth, fillColor, pathData, valueType` с нэймспэйсом библиотеки VectorCompat.
Другое ограничение выражается в том, что мы не можем VectorDrawable напрямую указать, как background для view в XML-ресурсе макета. Для использования VectorDrawable мы должны загрузить его из XML-ресурса в java-коде и уже там указать его как фон для ImageView.
Библиотека предлагает три метода для загрузки VectorDrawable из XML: `VectorDrawable.getDrawable(), AnimatedVectorDrawable.getDrawable()` и `ResourcesCompat.getDrawable()`. Третий метод предпочтительнее по двум причинам: во-первых при его использовании нет разницы, объект какого класса мы пытаемся загрузить — VectorDrawable или AnimatedVectorDrawable, а во-вторых, на устройствах с Lollipop и выше, автоматически будет использовать нативный метод из Android SDK.
В остальном, никаких других особенностей использования векторной анимации с использованием библиотеки VectorCompat нет.
### Подготовка векторных файлов
В заключение необходимо обсудить тему подготовки файлов векторной графики для Android. Экспорт в формат SVG поддерживается большинством векторных редакторов, в том числе Corel Draw, Adobe Illustrator и Sketch. Однако, при использовании Adobe Illustrator возникает проблема с позиционированием изображения относительно `viewPort` — несмотря на то, что при просмотре в Illustrator изображение отцентрировано относительно `viewPort`, при открытии экспортированного SVG файла, к примеру, в браузере, оказывается смещен в сторону. Поэтому для использования SVG файлов из Illustrator предварительно их нужно пересохранить в другой программе, например бесплатной [Inkscape](https://inkscape.org/en/).
При этом не стоит забывать о том, что из всего множества SVG Android поддерживает только объекты `Path`. Поэтому примитивные фигуры, необходимо трансформировать в пути. В Sketch это делается командой Layer > Paths > Vectorize stroke, а в Illustrator > Object > Expand.
Имея в наличии файл SVG мы можем открыть его в текстовом редакторе и найти тэг ``. В нем нас интересует атрибут, озаглавленный d` — его значением является строка с командами. Скопировав эту строку, мы можем сохранить ее в нашем проекте и использовать в качестве значения атрибута `pathData` в файле VectorDrawable.
К сожалению, в Android Studio на данный момент отсутствует возможность редактирования векторных файлов, однако эта возможность должна появиться в будущих версиях. Также в версии 1.4 появился новый инструмент Vector Asset Studio — мы можем указать SVG файл и Vector Drawable из этого SVG будет создан автоматически. Для этого мы должны перейти в папку `res/drawable` и вызвать его через меню File > New > Vector Asset.
Пока что версия 1.4 находится в стадии Preview и мне удалось заставить ее работать только с SVG файлами из Illustrator. Также минимальная версия вашего проекта должна быть установлена (хотя бы на время импорта) на значение 21. Помимо этого поддерживается выбор из набора иконок Material Design. Использование данного инструмента избавляет от необходимости вручную копировать данные пути из SVG файлов, что может быть особенно востребованным, когда наше изображение состоит из множества фигур. Также в версии 1,4 Android плагина для Gradle должна появиться функция генерации набора png-файлов из векторных ресурсов при сборке проекта.
Широкое распространение SVG формата, а также наличие поддержки векторной графики на старых версиях Android снимают последние возражения относительно ее использования в реальных проектах. Требуйте от дизайнеров иконки в векторе и это избавит от необходимости готовить набор png файлов под все разрешения в случае изменения дизайна, также это позволяет уменьшить вес готового apk-файла. Всем vector!
Эта статья подготовлена по итогам моего выступления на митапе [Rambler.Android](http://habrahabr.ru/company/rambler-co/blog/265867/), прошедшем 10 сентября.
Вы также можете ознакомиться со [слайдами](http://www.slideshare.net/olegosipenko/android-vector-drawable-52671249) и [видеозаписью](https://www.youtube.com/watch?v=ZWwTfoDUIBA) выступления, а также ознакомиться с [исходным кодом примера](https://github.com/olegosipenko/AnimationExample), использованного в презентации
` | https://habr.com/ru/post/267073/ | null | ru | null |
# Гадание на нейросетях: отметился ли в комментариях к посту сам автор
Поделюсь рассказом о небольшом проекте: как найти в комментариях ответы автора, заведомо не зная кто автор поста.
Свой проект я начинал с минимальными знаниями по машинному обучению и думаю для специалистов тут не будет ничего нового. Этот материал в некотором смысле компиляция разных статей, в нем расскажу, как подходил к задаче, в коде можно найти полезные мелочи и приемы с обработкой естественного языка.
Мои исходные данные были следующими: БД содержащая 2.5М медиа-материалов и 39.5М комментариев к ним. Для 1М постов так или иначе автор материала был известен (эта информация либо присутствовала в БД, либо получалась посредством анализа данных по косвенным признакам). На этой основе был [сформирован](https://github.com/xeonvs/dnn_comments/blob/master/export_clean_dataframe.py) датасет из размеченных 215К записей.
Первоначально я применял подход на основе эвристик, выдаваемых естественным интеллектом и транслируемых в sql-запросы с полнотекстовым поиском или регулярными выражениями. Самые простейшие примеры текста для разбора: «спасибо за комментарий» или «благодарю вас за хорошие оценки» это в 99.99% случаев автор, а «спасибо за творчество» или «Благодарю! Пришлите на почту материал. Спасибо!» — обычный отзыв. С таким подходом можно было отфильтровать только явные совпадения исключая случаи банальных опечаток или, когда автор ведет диалог с комментаторами. Поэтому было решено использовать нейросети, идея эта пришла не без помощи друга.
Типичная последовательность комментариев, который из них авторский?
**Ответ**
За основу был взят метод определения тональности текста, задача проста у нас два класса: автор и не автор. Для обучения моделей я воспользовался [сервисом](https://colab.research.google.com/) от Гугла предоставляющем виртуальные машины с GPU и интерфейсом Jupiter notebook.
Примеры сетей, найденные на просторах Интернета:
```
embed_dim = 128
model = Sequential()
model.add(Embedding(max_fatures, embed_dim,input_length = X_train.shape[1]))
model.add(SpatialDropout1D(0.2))
model.add(LSTM(196, dropout=0.5, recurrent_dropout=0.2))
model.add(Dense(1,activation='softmax'))
model.compile(loss = 'binary_crossentropy', optimizer='adam',metrics = ['accuracy'])
```
на строках, очищенных от html-тегов и спецсимволов, давали порядка 65-74% процентов точности, что не сильно отличалось от подбрасывания монетки.
Интересный момент, выравнивание входных последовательностей через `pad_sequences(x_train, maxlen=max_len, padding=’pre’)` давало существенную разницу в результатах. В моём случае, лучший результат был при padding=’post’.
Следующим этапом стало применение лемматизации, что сразу дало прирост точности до 80% и с этим уже можно было работать дальше. Теперь основной проблемой стала корректная очистка текста. К примеру, опечатки в слове «спасибо», конвертировались(опечатки выбирались по частоте использования) в такое регулярное выражение (подобных выражений накопилось полтора-два десятка).
```
re16 = re.compile(ur"(?:\b:(?:1спасибо|cп(?:асибо|осибо)|м(?:ерси|уррси)|п(?:ас(?:асибо|и(?:б(?:(?:ки|о(?:чки)?|а))?|п(?:ки)?))|осибо)|с(?:а(?:п(?:асибо|сибо)|сибо)|басибо|енкс|ибо|п(?:а(?:асибо|всибо|и(?:бо|сбо)|с(?:бо|и(?:б(?:(?:бо|ки|о(?:(?:за|нька|ч(?:к[ио]|ьки)|[ко]))?|[арсі]))?|ки|ьо|1)|сибо|тбо)|чибо)|всибо|исибо|осиб[ао]|п(?:асибо|сибо)|с(?:(?:а(?:иб[ао]|сибо)|бо?|и(?:б(?:(?:ки|о(?:всм)?))?|п)|с(?:ибо|с)))?)|расибо|спасибо)|тхан(?:кс|x))\b)", re.UNICODE)
```
Здесь хочется выразить отдельную благодарность чрезмерно вежливым людям, которые считают необходимым добавлять это слово в каждое свое предложение.
Уменьшение доли опечаток было необходимо, т.к. на выходе с лемматизатора они дают странные слова и мы теряем полезную информацию.
Но нет худа без добра, устав бороться с опечатками, заниматься сложной очисткой текста, применил способ векторного представления слов — word2vec. Метод позволил перевести все опечатки, описки и синонимы в близко расположенные вектора.
Слова и их отношения в векторном пространстве.
Правила очистки были существенно упрощены (ага, сказочник), все сообщения, имена пользователей, были разбиты на предложения и выгружены в файл. Важный момент: ввиду краткости наших комментаторов, для построения качественных векторов, к словам нужна дополнительная контекстная информация, например, с форума и википедии. На полученном файле были обучены три модели: классический word2vec, Glove и FastText. После многих экспериментов окончательно остановился на FastText, как наиболее качественно выделяющей кластеры слов в моём случае.
Все эти изменения принесли стабильные 84-85 процентов точности.
**Примеры моделей**
```
def model_conv_core(model_input, embd_size = 128):
num_filters = 128
X = Embedding(total_unique_words, DIM, input_length=max_words, weights=[embedding_matrix], trainable=False, name='Word2Vec')(model_input)
X = Conv1D(num_filters, 3, activation='relu', padding='same')(X)
X = Dropout(0.3)(X)
X = MaxPooling1D(2)(X)
X = Conv1D(num_filters, 5, activation='relu', padding='same')(X)
return X
def model_conv1d(model_input, embd_size = 128, num_filters = 64, kernel_size=3):
X = Embedding(total_unique_words, DIM, input_length=max_words, weights=[embedding_matrix], trainable=False, name='Word2Vec')(model_input)
X = Conv1D(num_filters, kernel_size, padding='same', activation='relu', strides=1)(X)
# X = Dropout(0.1)(X)
X = MaxPooling1D(pool_size=2)(X)
X = LSTM(256, kernel_regularizer=regularizers.l2(0.004))(X)
X = Dropout(0.3)(X)
X = Dense(128, kernel_regularizer=regularizers.l2(0.0004))(X)
X = LeakyReLU()(X)
X = BatchNormalization()(X)
X = Dense(1, activation="sigmoid")(X)
model = Model(model_input, X, name='w2v_conv1d')
return model
def model_gru(model_input, embd_size = 128):
X = model_conv_core(model_input, embd_size)
X = MaxPooling1D(2)(X)
X = Dropout(0.2)(X)
X = GRU(256, activation='relu', return_sequences=True, kernel_regularizer=regularizers.l2(0.004))(X)
X = Dropout(0.5)(X)
X = GRU(128, activation='relu', kernel_regularizer=regularizers.l2(0.0004))(X)
X = Dropout(0.5)(X)
X = BatchNormalization()(X)
X = Dense(1, activation="sigmoid")(X)
model = Model(model_input, X, name='w2v_gru')
return model
def model_conv2d(model_input, embd_size = 128):
from keras.layers import MaxPool2D, Conv2D, Reshape
num_filters = 256
filter_sizes = [3, 5, 7]
X = Embedding(total_unique_words, DIM, input_length=max_words, weights=[embedding_matrix], trainable=False, name='Word2Vec')(model_input)
reshape = Reshape((maxSequenceLength, embd_size, 1))(X)
conv_0 = Conv2D(num_filters, kernel_size=(filter_sizes[0], embd_size), padding='valid', kernel_initializer='normal', activation='relu')(reshape)
conv_1 = Conv2D(num_filters, kernel_size=(filter_sizes[1], embd_size), padding='valid', kernel_initializer='normal', activation='relu')(reshape)
conv_2 = Conv2D(num_filters, kernel_size=(filter_sizes[2], embd_size), padding='valid', kernel_initializer='normal', activation='relu')(reshape)
maxpool_0 = MaxPool2D(pool_size=(maxSequenceLength - filter_sizes[0] + 1, 1), strides=(1,1), padding='valid')(conv_0)
maxpool_1 = MaxPool2D(pool_size=(maxSequenceLength - filter_sizes[1] + 1, 1), strides=(1,1), padding='valid')(conv_1)
maxpool_2 = MaxPool2D(pool_size=(maxSequenceLength - filter_sizes[2] + 1, 1), strides=(1,1), padding='valid')(conv_2)
X = concatenate([maxpool_0, maxpool_1, maxpool_2], axis=1)
X = Dropout(0.2)(X)
X = Flatten()(X)
X = Dense(int(embd_size / 2.0), activation='relu', kernel_regularizer=regularizers.l2(0.004))(X)
X = Dropout(0.5)(X)
X = BatchNormalization()(X)
X = Dense(1, activation="sigmoid")(X)
model = Model(model_input, X, name='w2v_conv2d')
return model
```
и еще 6 моделей в [коде](https://github.com/xeonvs/dnn_comments). Часть моделей взята из сети, часть придумана самостоятельно.
Было замечено, что на разных моделях выделялись разные комментарии, это натолкнуло на мысль воспользоваться ансамблями моделей. Сначала я собирал ансамбль вручную, выбирая наилучшие пары моделей, потом сделал генератор. С целью оптимизировать полный перебор — взял за основу код грея.
```
def gray_code(n):
def gray_code_recurse (g,n):
k = len(g)
if n <= 0:
return
else:
for i in range (k-1, -1, -1):
char='1' + g[i]
g.append(char)
for i in range (k-1, -1, -1):
g[i]='0' + g[i]
gray_code_recurse (g, n-1)
g = ['0','1']
gray_code_recurse(g, n-1)
return g
def gen_list(m):
out = []
g = gray_code(len(m))
for i in range (len(g)):
mask_str = g[i]
idx = 0
v = []
for c in list(mask_str):
if c == '1':
v.append(m[idx])
idx += 1
if len(v) > 1:
out.append(v)
return out
```
С ансамблем «жизнь стала веселее» и текущий процент точности модели держится на уровне 86-87%, что связано по большей степени с некачественной классификацией части авторов в датасете.
Встреченные мной проблемы:
1. Несбалансированный датасет. Количество комментариев от авторов было существенно меньше остальных комментаторов.
2. Классы в выборке идут в строгой очередности. Суть в том, что начало, середина и конец существенно отличаются по качеству классификации. Это хорошо заметно в процессе обучения по графику f1-меры. 
Для решения был сделан свой велосипед для разделения на обучающую и валидационную выборки. Хотя на практике в большинстве случаев хватит процедуры train\_test\_split из библиотеки sklearn.
Граф текущей рабочей модели:
В итоге я получил модель с уверенным определением авторов по коротким комментариям. Дальнейшие улучшение будет связано с очисткой и перенесением результатов классификации реальных данных в тренировочный датасет.
Весь код с дополнительными пояснениями в выложен [репозитории](https://github.com/xeonvs/dnn_comments).
В качестве постскриптума: если вам надо классифицировать большие объемы текста, взгляните на модель «Very Deep Convolutional Neural Network» [VDCNN](https://arxiv.org/abs/1606.01781) ([реализация](https://github.com/zonetrooper32/VDCNN) на keras), это аналог ResNet для текстов.
Использованные материалы:
• [Обзор курсов по машинному обучению](https://habr.com/ru/post/417209/)
• [Анализ тональностей с помощью свёрток](https://habr.com/ru/company/mailru/blog/417767/)
• [Сверточные сети в NLP](https://habr.com/ru/company/ods/blog/353060/)
• [Метрики в машинном обучении](https://habr.com/ru/company/ods/blog/328372/)
<https://ld86.github.io/ml-slides/unbalanced.html>
• [Взгляд внутрь модели](https://habr.com/ru/post/438972/) | https://habr.com/ru/post/441850/ | null | ru | null |
# MastermindCMS2 vs Next.js
Вступление
----------
Подходит к концу 2021 г. и я думаю сейчас самое время подвести итоги как продвигалась веб разработка в условиях пандемии в мире и какие технологии сейчас используются для веб-программирования.
Сегодня я хотел бы затронуть тему фреймворков. И сделать небольшое сравнение с одной малоизвестной технологией. Основную лидирующую позицию, в рейтинге самых популярных фреймворков для веб-разработки, сейчас занимает - фреймворк **React**.
Платформы с предложениями о работе в IT-сфере, просто кишат вакансиями фронтенд разработчиков имеющих опыт разработки на фреймворке **React**.
С одной стороны **React** нам дал возможность частями программировать интерфейс пользователя, разбирая его на части. А с другой стороны мы получили «молоток и гвозди» с помощью которых нам придется построить дом. И получилось так что сообщество программистов использует фреймворк **React**, чтобы написать свой фреймворк. И поэтому на рынке появляются новые фреймворки, основанные на **React**, которые уже решают конкретные задачи на реальных проектах. Одним из таких фреймворков является **Next.js**.
Меня подтолкнуло к написанию данной статьи, огромное количество статей и обучающих видео в интернет пространстве о возможностях **Next.js**. А конкретнее сказать, я начал разбираться в чем же всё-таки преимущество этого **Next.js**. И к моему удивлению, я понял, что **MastermindCMS2**, которую я успешно использую на множестве проектов, решает те же проблемы, что и пытались решить разработчики **Next.js**.
А вот что конкретно сделали разработчики **Next.js** мы рассмотрим и сравним в этой статье с технологией **MastermindCMS2**. Поехали!
Фичи и их сравнение
-------------------
Ключевые фичи фреймворка Next.js### Next.js
Первая фича о которой заявляют разработчики **Next.js** это роутинг основанный на файловой системе. Это дает возможность создавать папки и вкладывая в них страницы так что это будет будущим адресом на вашем сайте. Это очень удобно, и таким образом становится очень прозрачно разрабатывать ваше приложение. Что собственно еще очень хорошо влияет на **SEO**.
### MastermindCMS2
В **MastermindCMS2** реализовано ровно также, и разница только в реализации динамических страниц. Сейчас покажу в чем разница, а судить уже вам, где удобнее или прозрачнее.
Динамический роутинг страниц
----------------------------
### Next.js
Для динамических страниц в **Next.js** есть специальный синтаксис в названии страниц, следующего вида **[pageId].js**, вместо **pageId** можно использовать разные названия переменных которые вы впоследствии сможете использовать для извлечения необходимой сущности из БД.
Во входящем объекте **router** из библиотеки **Next.js**,который должен быть импортирован на страницу, где будет лежать ваше значение в переменной которая будет считана из названия файла. Ниже пример как это должно быть реализовано:
Пример реализации динамических страниц в Next.jsВ этом видео ниже вы можете подробнее ознакомиться.
### MastermindCMS2
С **MastermindCMS2** реализация динамических страниц выглядит иначе. Поскольку основной принцип технологии **MastermindCMS2** лежит в том чтобы четко разделить логику шаблона, от визуальных манипуляций с **DOM**, и вся логика динамической страницы будет внутри HTML-документа.
Для реализации динамической страницы нам понадобиться MSM-тег .
Пример:
Пояснение:
Для передачи значения из адресной строки используется специальный синтаксис @url|id, вместо id нужно указать значение переменной из адресной строкиПример**:**
То есть **our-domain.com/site/pages/rest-api/shipId/9.html**, **shipId** в данном примере является названием переменной, а число 9 её значением.
Узловая страница находится в папке **pages** под названием **rest-api.html**. Узловая страница является точкой входа для парсинга динамических значений.
Путь на файловой системе где находится узловая страницаОтличие от Next.js:
В **MastermindCMS2** в отличии от **Next.js** существует возможность передать не только строку, а даже целый JSON объект. В этом видео ниже показан пример как это сделать:
Server-side Rendering
---------------------
### Next.js
Здесь я думаю не стоит сильно объяснять что это такое, напишу кратко. Это означает что при первом запросе страницы браузер получит все содержимое страницы уже от веб-сервера. Все **React**-подобные фреймворки грешат тем, что они имеют пустой элемент на странице, тот что им вернул веб-сервер и уже когда браузер загружает страницу, **React** начинает выполнять инструкции для отрисовки внешности сайта, что как бы для SEO не приветствуется. Но разработчики **Next.js** решили эту проблему реализовав **SSR** в своем фреймворке. В видео про **Next.js**, которое я скинул выше вы можете также подробнее ознакомиться.
### MastermindCMS2
В MastermindCMS2 также реализован серверный рендеринг, в этом вы можете убедиться посмотрев исходный код страницы на официальном сайте [MastermindCMS2](https://mastermindcms.co). Он также запущен на моей технологии.
Интеграции и backend-разработка
-------------------------------
Next.js
-------
В **Next.js** как и в любой другой **React**-библиотеке есть огромный набор инструментов который поможет вам построить быстро клиента для получения данных с внешних веб-ресурсов.
### MastrermindCMS2
В **MastrermindCMS2** у вас также руки развязаны в использовании различных **JavaScript**-библиотек и вы также можете можете писать клиентскую логику которая будет получать данных с внешних источников.
У **MastermindCMS2** есть также возможность работать с данными на **JavaScript**, получать JSON-объект, а затем выполнять рендеринг на клиенте различными фреймворками.
Системные зависимости
---------------------
### Next.js
Как технология имеющая бекенд-логику должна быть запущена на сервере-приложений **Node.js**.
### MastermindCMS2
**MastermindCMS2** полностью построен на Java. Поэтому для его установки вам потребуется **Java 11**. Посколько **MastermindCMS2** это еще и **headless cms**, то вы можете легко подключить **MongoDB**, и уже вам не нужно будет думать какую БД интегрировать.
Резюме и таблица сравнения
--------------------------
| | | |
| --- | --- | --- |
| **Список возможностей из «коробки»** | **Next.js** | **MastermindCMS2** |
| Роутинг на основе файловой системы | **+** | **+** |
| Серверный рендеринг | **+** | **+** |
| Клиентский рендеринг | **С помощью React** | **+** |
| JavaScript библиотека с функциями | **+** | **+** |
| Роутинг на клиенте | **С помощью React** | **+** |
| Интеграция с внешними сервисами | **+** | **+** |
| Интеграции с другими фреймворками | **+** | **+** |
| Интеграция с базой-данных MongoDB | **В разработке** | **+** |
| Привязка к данным | **С помощью React** | **+** |
| Протокол взаимодействия с данными на WebSockets | **-** | **+** |
| Ленивая загрузка блоков HTML | **С помощью React** | **+** |
| Компилируемый бекенд | **-** | **+** |
| Инфраструктура серверов | **+** | **-** |
| Возможность контейнеризации | **+** | **+** |
| Установочные пакеты DEB/RPM | **-** | **+** |
| Пакет на NPM | **+** | **-** |
| Open-Source | **+** | **-** |
Что мы имеем в итоге, две схожих технологии по своей сути, с разными реализациями на разных технологических стеках. Да сейчас эра **React**, и вся веб-разработка «завязана» на использовании этой инфраструктуры с множеством различных решений построенных на фреймворке **React**. С одной стороны сайты стали сложнее и с другой стороны есть жесткие требования к оптимизации страниц со стороны **Google**. Из-за этого фронтенд разработка сейчас превратилась в нечто комплексное, и громоздкое. Конечно на эту тенденцию еще повлиял **Node.js**. Сейчас трудно представить фронтенд приложение без использования **npm**.
Также многие разработчики фреймворков и «безголовых» CMS строят облачные решения на основе своих технологий, собственно **Next.js** тому пример. Компания **Vercel** получила инвестиции в размере 163 млн. долларов и успешно закрепилась на рынке, построив облачные решения. Для **MastermindCMS2** этот путь еще не пройден, кто знает что будет завтра… | https://habr.com/ru/post/593361/ | null | ru | null |
# Условия if...else
###### Доброго времени суток Хабралюди!
Сегодня для меня великий день.
В вопросах я писал о краткой справке для новичков и профессионалов, думалось мне что я сейчас быстро окунусь в язык, сделаю всем добро и пойду дальше изучать свой *Perl*.
Но как всегда всё пошло не так...
Взявшись за изучение у меня был небольшой блокнотик, стул на кухне и распечатанная табличка *ASCII* кодов. Каждый новый шаг был для меня, как новый рекорд, новая высота.
Иногда запускал на компьютере *BrainfuckIDE* и экспериментировал. Эксперименты были достаточно плодотворные, и уже через 5-6 часов я изучил его досконально. Помнил все алгоритмы сложения, вычитания, перемещения, копирования, деления и умножения. Элементарные сложение, вычитание и перемещение я подсмотрел на каком то из сайтов, остальное додумал сам.
Потом ~~посерфил~~ поискал в интернете и увидел что на нём оказывается можно делать условия(то было для меня удивлением). Главный вопрос: **Как?**
Не став изучать и принтскрить алгоритм себе в мозг, сел с тетрадочкой в угол и начал думать.
Думал я до эффекта полной абстракции от мира сего. Ушло две тетрадки, в которых я пробовал кучу разных вариантов, перемещал, копировал, пытался как то сравнивать, расплывчатые идеи при их реализации на листке, к концу приводили к очередному хаосу в моей голове.
Поставив перед собой цель написать программу, которая будет сравнивать введённое число с заведомо известным, и выводить результат(равно или не равно), я два дня практически без отдыха(только сон, еда, туалет и dota) сидел и воображал как это реализовать, на столь ~~запутанном~~ прекрасном языке.
Лёг спать достаточно поздно(10 утра), не мог заснуть когда в моей голове вертелось такое.
Проснувшись ближе к вечеру, взял недописанную вторую тетрадь и начал писать, честно говоря, я сам не понимаю как к такому алгоритму я пришёл, но на листочке через 2 часа он казался рабочим. Сел за нэтбук, на стационарном в это время ставилась новая ось.
Начал переписывать с листочка, оказалось я не учёл очень много вопросов и подводных камней, но алгоритм всё ещё казался верным.
За компьютером его отладка заняла не больше часа, как вдруг, перед моими глазами программа очнулась, работая именно так, как я того хотел.
Ощущение непередаваемое, такое чувство что ты планету открыл. Первые мои слова были: "~~Б\*ля~~ Ну вот, наконец то!". Немного отладив, убрал кучу + и -, заменив их на циклы всё работало как в сказке.
*Не сильно закидывайте помидорами и тухлыми яйцами, но я попробую рискнуть и привести код, который написал. Смотрите:*
```
,[>+>+<<-]>>[<<+>>-] # Копируем введённое значение в 1 ячейку
+++++ +++++[<----->-]<--- # Уменьшаем её на ascii код числа с которым сравниваем
>>+>>+<<<< # Счётчики для циклов
[ # Цикл Если n != 5
[-]+++++ +++++[>+++++<-]>+++. # Выводим 5
[-]<++++++++[>++++<-]>. # Выводим пробел
[-]<++++++++[>++++<-]>+. # Выводим восклицательный знак
[-]<++++++++++[>++++++<-]>+. # Выводим знак равенства
[-]<++++++++[>++++<-]>.<<. # Выводим пробел и число n
>>>>>-<<-] # Обнуляем счётчики, что бы второй цикл не выполнился
>>[ # Цикл иначе, практически всё тоже самое
[-]+++++ +++++[>+++++<-]>+++.
[-]<++++++++[>++++<-]>.
[-]<++++++++++[>++++++<-]>+.
[-]<++++++++[>++++<-]>.<<<<.
>>>>>-]
```
Как видите, основная идея в том, что бы цикл выполнялся тогда и только тогда, когда остаток от разности чисел n и ascii кода числа с которым сравнивают != 0.
Думаю это будет достаточно наглядный пример для начинающих, а от Вас Уважаемые гуру и ниндзя этого языка, прошу совета и возможно критики.
Ещё интересуют вопросы:
* Как остальные решили бы данный вопрос?
* Правильно ли я выбрал алгоритм, или можно обойтись более простым?
* Что здесь можно ещё оптимизировать, и можно ли вообще? | https://habr.com/ru/post/140152/ | null | ru | null |
# Пример разработки блога на Zend Framework 2. Часть 3. Работа с пользователями
Это третья (последняя?) часть статьи, посвященной разработке простого приложения при помощи Zend Framework 2. [В первой части](http://habrahabr.ru/post/192522/) я рассмотрел структуру ZendSkeletonApplication, [во второй части](http://habrahabr.ru/post/192608/) привел пример разработки простого модуля. Эта часть посвящена работе с пользователями, а также я прикручу к проекту шаблонизатор Twig.
Работа с пользователями
-----------------------
Код написанный в предыдущих частях, позволяет создавать, редактировать и удалять блогпосты всем посетителям сайта. Такой подход неприемлем для любого рабочего сайта, поэтому сейчас настало время решить вопросы регистрации/авторизации и распределения прав доступа к различным возможностям приложения.
### Zf Commons
Для Zend фреймворка написано достаточно много модулей, решающих стандартные задачи, найти их можно на специальном сайте: [modules.zendframework.com](http://modules.zendframework.com/). Вместо разработки своих велосипедов для решения стандартных задач я считаю более правильным использовать/адаптировать под себя готовые решения (по крайней мере готовые решения нужно изучить прежде чем браться за разработку велосипеда).
Среди множества разработчиков модулей выделяется команда ZF Commons, ребятами из этой команды разработан ряд очень полезных модулей, которые мы будем использовать в этом проекте: [github.com/ZF-Commons](https://github.com/ZF-Commons). Рассмотрим некоторые из них, которые необходимы нам на данном этапе.
#### ZfcBase
Ядро, от которого зависят другие модули ZF Commons (<https://github.com/ZF-Commons/ZfcBase>).
#### ZfcUser
Модуль, реализующий механизмы регистрации/авторизации пользователей, профиль пользователя и View хелперы для использования в шаблонах (<https://github.com/ZF-Commons/ZfcUser>).
#### ZfcUserDoctrineORM
По умолчанию, ZfcUser работает со стандартным для фреймворка механизмом работы с БД, так как в нашем проекте используется Doctrine ORM, также нужен модуль ZfcUserDoctrineORM (<https://github.com/ZF-Commons/ZfcUserDoctrineORM>).
#### ZfcTwig
Модуль для интеграции с шаблонизатором Twig (<https://github.com/ZF-Commons/ZfcTwig>).
### BjyAuthorize
Кроме модулей от ZfCommons я буду использовать модуль BjyAuthorize, который предоставляет удобный механизм для распределения прав доступа. Логика работы модуля простая и распространенная среди других фреймворков. Модуль оперирует понятиями: пользователь, роль и guard.
Пользователь может быть авторизованным и не авторизованным. Авторизованный пользователь может иметь одну или несколько ролей. Guard в данном контексте — это контроллер/действие, к которому мы настраиваем права доступа для разных ролей.
### Подготовка к настройке пользователей
Прежде чем настраивать работу с пользователями необходимо создать entity для пользователя и роли, которые будут использоваться Доктриной. В комплекте с модулем BjyAuthorize идут примеры таких сущностей, на их основе я создал модуль MyUser.
Модуль не содержит ничего оригинального, посмотреть его код можно тут: [github.com/romka/zend-blog-example/tree/master/module/MyUser](https://github.com/romka/zend-blog-example/tree/master/module/MyUser), по своей структуре он не отличается от рассмотренных выше модулей Application и MyBlog: содержит конфиг и 2 entity.
Следует обратить внимание только на его конфиг (<https://github.com/romka/zend-blog-example/blob/master/module/MyUser/config/module.config.php>):
```
return array(
'doctrine' => array(
'driver' => array(
'zfcuser_entity' => array(
'class' =>'Doctrine\ORM\Mapping\Driver\AnnotationDriver',
'paths' => array(__DIR__ . '/../src/MyUser/Entity')
),
'orm_default' => array(
'drivers' => array(
'MyUser\Entity' => 'zfcuser_entity',
)
)
)
),
'zfcuser' => array(
// telling ZfcUser to use our own class
'user_entity_class' => 'MyUser\Entity\User',
// telling ZfcUserDoctrineORM to skip the entities it defines
'enable_default_entities' => false,
),
'bjyauthorize' => array(
// Using the authentication identity provider, which basically reads the roles from the auth service's identity
'identity_provider' => 'BjyAuthorize\Provider\Identity\AuthenticationIdentityProvider',
'role_providers' => array(
// using an object repository (entity repository) to load all roles into our ACL
'BjyAuthorize\Provider\Role\ObjectRepositoryProvider' => array(
'object_manager' => 'doctrine.entity_manager.orm_default',
'role_entity_class' => 'MyUser\Entity\Role',
),
),
),
);
```
В этом конфиге мы заменяем сущность zfcuser на нашу собственную, которая отвечает за работу с пользователем и указываем модулю BjyAuthorize сущность, отвечающую за работу с ролями.
Модуль MyUser нужно добавить в *application.config.php* и затем в консоли выполнить команды:
```
./vendor/bin/doctrine-module orm:schema-tool:update --force
./vendor/bin/doctrine-module orm:validate-schema
```
Первую — чтобы создать в БД таблицы для сущностей, созданных модулем MyUser, вторую — чтобы убедиться, что первая команда отработала корректно.
Последним подготовительным действием будет выполнение запроса, который создаст соответствующие роли:
```
INSERT INTO `role`
(`id`, `parent_id`, `roleId`)
VALUES
(1, NULL, 'guest'),
(2, 1, 'user'),
(3, 2, 'moderator'),
(4, 3, 'administrator');
```
### Настройка ZfcUser, ZfcUserDoctrineORM и BjyAuthorize
Первым делом необходимо прописать новые модули в настройках Композера:
```
"zf-commons/zfc-base": "v0.1.2",
"zf-commons/zfc-user": "dev-master",
"zf-commons/zfc-user-doctrine-orm": "dev-master",
"doctrine/doctrine-orm-module": "0.7.*",
"bjyoungblood/bjy-authorize": "1.4.*"
```
выполнить апдейт *php composer.phar update* и добавить новые модули в *application.config.php*:
```
'ZfcBase',
'ZfcUser',
'ZfcUserDoctrineORM',
'BjyAuthorize',
```
Внимание! Настройки некоторых из этих модулей будут переопределены настройками самописных модулей, поэтому эти модули необходимо добавить вверх списка.
Теперь нужно скопировать файл *zfcuser.global.php.dist* из директории *vendor/zf-commons/zfc-user/config* в *config/autoload* и переименовать его в *zfcuser.global.php*. В этом конфигурационном файле нужно задать значение:
```
'table_name' => 'users',
```
так как по умолчанию для работы с пользователями используется таблица user.
Еще в этой же директории нужно создать конфигурационный файл *bjyauth.global.php* содержащий настройки прав доступа для различных ролей. Полную версию этого файла вы можете посмотреть на Гитхабе [github.com/romka/zend-blog-example/blob/master/config/autoload/bjyauth.global.php](https://github.com/romka/zend-blog-example/blob/master/config/autoload/bjyauth.global.php), самая интересная его часть, которая отвечает за распределение прав доступа к различным контроллерам, приведена ниже:
```
'guards' => array(
/* If this guard is specified here (i.e. it is enabled), it will block
* access to all controllers and actions unless they are specified here.
* You may omit the 'action' index to allow access to the entire controller
*/
'BjyAuthorize\Guard\Controller' => array(
array(
'controller' => 'zfcuser',
'action' => array('index', 'login', 'authenticate', 'register'),
'roles' => array('guest'),
),
array(
'controller' => 'zfcuser',
'action' => array('logout'),
'roles' => array('user'),
),
array('controller' => 'Application\Controller\Index', 'roles' => array()),
array(
'controller' => 'MyBlog\Controller\BlogPost',
'action' => array('index', 'view'),
'roles' => array('guest', 'user'),
),
array(
'controller' => 'MyBlog\Controller\BlogPost',
'action' => array('add', 'edit', 'delete'),
'roles' => array('administrator'),
),
),
),
```
Из конфига видно, что доступ к экшенам index и view мы сделали для всех пользователей, а к экшенам add/edit/delete — только пользователям с ролью administrator. Сейчас в этом легко убедиться перейдя по ссылке /blog/add — будет возвращена ошибка 403.
Сейчас мы можем зарегистрироваться по ссылке /user/register и присвоить своему пользователю права администратора SQL-запросом:
```
INSERT INTO user_role_linker (user_id, role_id) VALUES (1, 4);
```
(да, админку для управления ролями пользователя модуль ZfcUser не предоставляет).
После авторизации внизу страницы в девелопер тулбаре будет выведена информация о роли текущего пользователя и действия add/edit/delete больше не будут возвращать ошибку 403.
Заметным недостатком текущего состояния проекта является то, что ссылки на редактирования/удаление блогпостов выводятся всем пользователям, несмотря на то, что у анонимов прав на выполнение таких действий нет. Модуль *BjyAuthorize* содержит View-плагин *isAllowed*, который позволяет легко исправить проблему. Добавим в шаблоны строчки такого вида:
```
if ($this->isAllowed('controller/MyBlog\Controller\BlogPost:edit')) {
// some code here
}
```
там где нужно проверить наличие прав доступа к соответствующим контроллеру/действию, это позволит не выводить в шаблоне ссылки, просмотр которых недоступен текущему пользователю.
Аналогичным методом можно в экшене indexAction() для админов выводить полный список блогпостов, а не только опубликованные:
```
if ($this->isAllowed('controller/MyBlog\Controller\BlogPost:edit')) {
$posts = $objectManager
->getRepository('\MyBlog\Entity\BlogPost')
->findBy(array(), array('created' => 'DESC'));
}
else {
$posts = $objectManager
->getRepository('\MyBlog\Entity\BlogPost')
->findBy(array('state' => 1), array('created' => 'DESC'));
}
```
Проект в текущем виде доступен в репозитории на Гитхабе с тэгом *configured\_user*: [github.com/romka/zend-blog-example/tree/configured\_user](https://github.com/romka/zend-blog-example/tree/configured_user).
Twig
----
На своей практике я использовал несколько различных шаблонизаторов и считаю питоновский [Jinja 2](http://jinja.pocoo.org/docs/) самым удобным из тех, с которыми мне приходилось работать. PHP-шаблонизатор [Twig](http://twig.sensiolabs.org/) изначально был разработан Armin’ом Ronacher’ом — автором Jinja 2, а затем за его поддержку и развитие взялся Fabien Potencier — разработчик фреймворка [Symfony](http://symfony.com/).
Одним из ключевых отличий Твига от встроенного в Zend Framework шаблонизатора является то, что в Twig-шаблонах нельзя использовать PHP-код, вместо этого в шаблонизаторе реализован собственный синтаксис для реализации циклов, условных операторов и т.п. Twig-шаблоны компилируются в PHP-код и как следствие не проигрывают в производительности PHP-коду.
Благодаря таким особенностям как наследование шаблонов, макросы, система фильтров и т.п. Twig-шаблоны получаются компактными и легко читаемыми.
### Установка
Для установки Твига достаточно выполнить стандартные действия: добавить строчку в *composer.json*, запустить *php composer.phar update* и добавить модуль в *application.config.php*.
Теперь к модулям, которые будут использовать этот шаблонизатор, в конфигурационный файл в секцию view\_manager нужно добавить строчки:
```
'strategies' => array(
'ZfcTwigViewStrategy',
),
```
и Твиг будет готов к использованию. Причем оба шаблонизатора (Твиг и дефолтный) могут использоваться вместе, то есть часть шаблонов может быть реализована на одном шаблонизаторе, часть на другом.
### Twig-шаблоны
Упомянутое выше наследование шаблонов означает, что мы можем создать дефолтный шаблон *layout.twig* примерно с таким содержимым:
```
{% block title %}Default title{% endblock title %}
{% block script %}
{% endblock script %}
{% block content %}{{ content|raw }}{% endblock content %}
{% block sidebar %}{{ sidebar|raw }}{% endblock sidebar %}
```
Далее мы можем создать шаблон, который будет наследоваться от layout.twig, в котором переопределим только изменившиеся части шаблона:
```
{% extends 'layout/layout.twig' %}
{% block script %}
{{ parent() }}
{% endblock script %}
{% block content %}
Custom content
{% endblock content %}
```
По умолчанию, блок переопределенный в шаблоне-наследнике заменяет собой блок в родительском шаблоне, но обратите внимание на строчку {{ parent() }} в блоке script, её использование означает, что в этот блок будет подгружено содержимое содержимое из аналогичного блока родительского шаблона.
Теперь давайте перепишем шаблоны с использованием нового шаблонизатора. Я начал со стандартного шаблона *layout.phtml* из Zend Skeleton Application, найти его можно в модуле MyBlog в директории view/layout [github.com/romka/zend-blog-example/blob/master/module/MyBlog/view/layout/layout.twig](https://github.com/romka/zend-blog-example/blob/master/module/MyBlog/view/layout/layout.twig).
Обратите внимание на то, насколько компактнее стало, например, использование view-хелперов, теперь вместо:
```
php
echo $this-url('blog', array('action' => 'edit'));
?>
```
можно вызвать:
```
{{ url('blog', {'action': 'edit'}) }}
```
а вместо:
```
php
echo $this-showMessages();
?>
```
просто:
```
{{ showMessages() }}
```
После переработки основного шаблона займемся формами. Первым делом в директории *view* модуля создадим поддиректорию *macros* и в ней файл [forms.twig](https://github.com/romka/zend-blog-example/blob/master/module/MyBlog/view/macros/forms.twig) с таким содержимым:
```
{% macro input(name, value, type, label, size, messages) %}
{% if type != 'hidden' %}
{% endif %}
{% if label %}
{{ label }}:
{% endif %}
{% if type == 'textarea' %}
0 %}class="error"{% endif %}/>{{ value|e }}
{% elseif type == 'checkbox' %}
0 %}class="error"{% endif %}/>
{% else %}
0 %}class="error"{% endif %}/>
{% endif %}
{% if type != 'hidden' %}
{% endif %}
{% if messages|length > 0 %}
{% for m in messages %}
* {{ m }}
{% endfor %}
{% endif %}
{% endmacro %}
```
Этот макрос будет использоваться для отображения полей форм. На вход он получает параметры поля, на выходе возвращает html-разметку.
Сейчас можно удалить существующий шаблон *add.phtml* и заменить новым *add.twig* с таким содержимым:
```
{% extends 'layout/layout.twig' %}
{% import 'macros/forms.twig' as forms %}
{% block content %}
{{ title }}
===========
{% for element in form %}
{{ forms.input(element.attributes.name, element.value, element.attributes.type, element.label, 20, element.messages) }}
{% endfor %}
{% endblock content %}
```
Аналогичным образом я переделал остальные шаблоны и поудалял теперь ставшие ненужными \*.phtml-шаблоны модуля: [github.com/romka/zend-blog-example/tree/master/module/MyBlog/view/my-blog/blog](https://github.com/romka/zend-blog-example/tree/master/module/MyBlog/view/my-blog/blog).
Заключение
----------
На этом я бы хотел закончить. Я не затронул массу важных моментов, таких как логгирование, кеширование, Dependency Injection, написание тестов и т.д и т.п, но все эти вопросы выходят за рамки ознакомительной статьи. Но я надеюсь, что для разработчиков начинающих изучать Zend Framework 2 эта статья поможет стать полезной отправной точкой.
*Я написал все 3 части этой статьи еще до публикации первой части и на момент завершения работы над текстом планировал на этом закончить. После прочтения комментариев я решил немного усовершенствовать приложение:
* использовать REST, вместо проверок на тип запроса GET/POST,
* перенести часть задач на хуки перед экшенами,
* перенести часть задач на хуки Доктрины,
* избавиться от магических констант,
* перенести конфиги в yaml,
* заменить часть вызовов на DI(?).
На подготовку этих изменений уйдет некоторое время, надеюсь опубликовать четвертую часть статьи в скором времени.* | https://habr.com/ru/post/192726/ | null | ru | null |
# Nuke: настраиваем сборку и публикацию .NET-проекта
Введение
--------
В настоящее время существует множество систем CI/CD. У всех есть определенные достоинства и недостатки и каждый выбирает себе наиболее подходящую под проект. Цель данной статьи - познакомить с Nuke на примере web-проекта, использующего уходящий на покой .NET-Framework с прицелом дальнейшего обновления до .NET 5. В проекте уже используется сборщик Fake, но возникла необходимость его обновления и доработки, что в итоге привело переходу на Nuke.
#### Исходные данные
* Web-проект, написанный на C#, в основе которого лежит .NET-Framework 4.8, Razor Pages + frontend скрипты на TypeScript, компилирующиеся в JS-файлы.
* Сборка и публикация приложения с помощью [Fake 4](https://fake.build/).
* Хостинг на AWS (Amazon Web Services)
* Окружения: Production, Staging, Demo
#### Цель
Необходимо обновить систему сборки, обеспечивая при этом расширяемость и гибкую настройку. Также нужно обеспечить настройку конфигурации в файле Web.config под заданное окружение.
Я рассматривал разные варианты систем сборки и в итоге выбор пал на [Nuke](https://www.nuke.build), так как он довольно простой и по сути представляет собой консольное приложение расширяемое за счёт пакетов. Кроме того, Nuke довольно динамично развивается и хорошо [документирован](https://www.nuke.build/docs/getting-started/setup.html). Плюсом идёт наличие плагина к IDE (среда разработки - Rider). Я отказался перехода на Fake 5 из-за стремления обеспечить языковое единство проекта и снизить порог входа, вновь пришедшим разработчикам. Кроме того, скрипты сложнее отлаживать. [Cake](https://cakebuild.net/), [Psake](https://github.com/psake/psake) также отбросил из-за "скриптовости".
### Подготовка
Nuke имеет dotnet tool, с помощью которого добавляется build-проект. Для начала установим его.
```
$ dotnet tool install Nuke.GlobalTool --global
```
Первоначальная настройка осуществляется командой `nuke :setup`, которая запускает текстовый wizard с вопросами названия проекта, расположения исходных файлов, каталога для артефактов и прочее.
В результате добавился проект \_buildВ каталоге boot лежат shell-скрипты для запуска сборщика.
Класс Build содержит основной код сборщика. Схема работы классическая - запускается цепочка взаимозависимых Target-ов. Вся информация выводится о процессе сборки выводится к консоль с помощью методов класса Logger. Например:
```
Logger.Info($"Starting build for {ApplicationForBuild} using {BuildEnvironment} environment");
```
Существует возможность передавать опции сборки через аргументы командной стройки. Для этого к полю класса Build применяется аттрибут [Parameter]. Ниже я приведу пример использования.
### Написание кода сборщика
В моем случае сборка и публикация проекта состоит нескольких этапов
1. Восстановление Nuget-пакетов
2. Сборка проекта
3. Публикация приложения
Перед непосредственным запуском настраиваю конфигурацию в зависимости от окружения и других параметров сборки, которые передаются через аргументы командной строки
```
[Parameter("Configuration to build - Default is 'Release'")]
readonly Configuration Configuration = Configuration.Release;
[Parameter(Name="application")]
readonly string ApplicationForBuild;
[Parameter(Name="environment")]
public readonly string BuildEnvironment;
```
Конфигуратор создается перед запуском сборки. Для этого я переопределяю метод базового класса OnBuildInitialized, который вызывается после того как, приведённые выше, параметры проинициализированы. Существует ещё несколько виртуальных методов в классе NukeBuild с префиксом On, вызываемые после определенных событий (например, старт/окончание сборки).
Код
```
protected override void OnBuildInitialized()
{
ConfigurationProvider = new ConfigurationProvider(ApplicationForBuild, BuildEnvironment, RootDirectory);
string configFilePath = $"./appsettings.json";
if (!File.Exists(configFilePath))
{
throw new FileNotFoundException($"Configuration file {configFilePath} is not found");
}
string configFileContent = File.ReadAllText(configFilePath);
if (string.IsNullOrEmpty(configFileContent))
{
throw new ArgumentNullException($"Config file {configFilePath} content is empty");
}
/* Настойка конфигурации typescript */
ToolsConfiguration = JsonConvert.DeserializeObject(configFileContent);
if (ToolsConfiguration == null || string.IsNullOrEmpty(ToolsConfiguration.TypeScriptCompilerFolder))
{
throw new ArgumentNullException($"Typescript compiler path is not defined");
}
base.OnBuildInitialized();
}
```
Код конфигурации
```
public class ApplicationConfig
{
public string ApplicationName { get; set; }
public string DeploymentGroup { get; set; }
/* Опции для замены в файле Web.config */
public Dictionary WebConfigReplacingParams { get; set; }
public ApplicationPathsConfig Paths { get; set; }
}
```
Непосредственно конфигуратор
```
public class ConfigurationProvider
{
readonly string Name;
readonly string DeployEnvironment;
readonly AbsolutePath RootDirectory;
ApplicationConfig CurrentConfig;
public ConfigurationProvider(string name,
string deployEnvironment,
AbsolutePath rootDirectory)
{
RootDirectory = rootDirectory;
DeployEnvironment = deployEnvironment;
Name = name;
}
public ApplicationConfig GetConfigForApplication()
{
if (CurrentConfig != null) return CurrentConfig;
string configFilePath = $"./BuildConfigs/{Name}/{DeployEnvironment}.json";
if (!File.Exists(configFilePath))
{
throw new FileNotFoundException($"Configuration file {configFilePath} is not found");
}
string configFileContent = File.ReadAllText(configFilePath);
if (string.IsNullOrEmpty(configFileContent))
{
throw new ArgumentNullException($"Config file {configFilePath} content is empty");
}
CurrentConfig = JsonConvert.DeserializeObject(configFileContent);
CurrentConfig.Paths = new ApplicationPathsConfig(RootDirectory, Name, CurrentConfig.ApplicationName);
return CurrentConfig;
}
}
```
#### Восстановление Nuget-пакетов
Этап очистки артефактов (Clean) я опускаю, так как он достаточно банален и сводится к удалению файлов. Процесс восстановления пакетов также прост: указываем пути к файлу конфигурации, к исполняемому файлу, рабочий каталог (RootDirectory) и папку для пакетов:
Код
```
Target Restore => _ => _
.DependsOn(Clean)
.Executes(() =>
{
NuGetTasks.NuGetRestore(config =>
{
config = config
.SetProcessToolPath(RootDirectory / ".nuget" / "NuGet.exe")
.SetConfigFile(RootDirectory / ".nuget" / "NuGet.config")
.SetProcessWorkingDirectory(RootDirectory)
.SetOutputDirectory(RootDirectory / "packages");
return config;
});
});
```
#### Сборка проекта
Код собирается в два шага. Сначала компилируется .NET-проект, далее TypeScript-файлы компилируются в JavaScript-код.
Код
```
Target Compile => _ => _
.DependsOn(Restore)
.Executes(() =>
{
AbsolutePath projectFile = ApplicationConfig.Paths.ProjectDirectory.GlobFiles("*.csproj").FirstOrDefault();
if (projectFile == null)
{
throw new ArgumentNullException($"Cannot found any projects in {ApplicationConfig.Paths.ProjectDirectory}");
}
MSBuild(config =>
{
config = config
.SetOutDir(ApplicationConfig.Paths.BinDirectory)
.SetConfiguration(Configuration) //указываем режим сборки: Debug/Release
.SetProperty("WebProjectOutputDir", ApplicationConfig.Paths.ApplicationOutputDirectory)
.SetProjectFile(projectFile)
.DisableRestore(); //так как мы восстановили пакеты на предыдущем этапе, то отключаем восстановление на этапе сборки
return config;
});
/* Запускаем tsc как отдельный процесс. Копируем файлы в каталог для публикации */
IProcess typeScriptProcess = ProcessTasks.StartProcess(@"node",$@"tsc -p {ApplicationConfig.Paths.ProjectDirectory}", ToolsConfiguration.TypeScriptCompilerFolder);
if (!typeScriptProcess.WaitForExit())
{
Logger.Error("Typescript build is failed");
throw new Exception("Typescript build is failed");
}
CopyDirectoryRecursively(ApplicationConfig.Paths.TypeScriptsSourceDirectory, ApplicationConfig.Paths.TypeScriptsOutDirectory, DirectoryExistsPolicy.Merge, FileExistsPolicy.Overwrite);
});
```
#### Публикация приложения
Проводится также в несколько этапов: подготовка артефактов и собственно публикация.
Сначала идёт трансформация конфигурации в файле Web.config под соответствующее окружение. Она заключается в замене значений определенных опций. Необходимые значения считываются из json-файла конфигурации окружения.
Все файлы архивируются и отправляются через CodeDeploy на сервер. Для работы с AWS я подключил NuGet-пакеты [AWSSDK](https://aws.amazon.com/ru/sdk-for-net/): AWSSDK.Core, AWSSDK.S3, AWSSDK.CodeDeploy. Я написал обертки над вызовами AWS CodeDeploy. Они особого интереса не предоставляют и служат скорее цели сокращения объема кода в классе Build.
Код
```
Target Publish => _ => _
.DependsOn(Compile)
.Executes(async () =>
{
PrepareApplicationForPublishing();
await PublishApplicationToAws();
});
void PrepareWebConfig(Dictionary replaceParams)
{
if (replaceParams?.Any() != true) return;
Logger.Info($"Setup Web.config for environment {BuildEnvironment}");
AbsolutePath webConfigPath = ApplicationConfig.Paths.ApplicationOutputDirectory / "Web.config";
if (!FileExists(webConfigPath))
{
Logger.Error($"{webConfigPath} is not found");
throw new FileNotFoundException($"{webConfigPath} is not found");
}
XmlDocument webConfig = new XmlDocument();
webConfig.Load(webConfigPath);
XmlNode settings = webConfig.SelectSingleNode("configuration/appSettings");
if (settings == null)
{
Logger.Error("Node configuration/appSettings in the config is not found");
throw new ArgumentNullException(nameof(settings),"Node configuration/appSettings in the config is not found");
}
foreach (var newParam in replaceParams)
{
XmlNode nodeForChange = settings.SelectSingleNode($"add[@key='{newParam.Key}']");
((XmlElement) nodeForChange)?.SetAttribute("value", newParam.Value);
}
webConfig.Save(webConfigPath);
}
void PrepareApplicationForPublishing()
{
AbsolutePath specFilePath = ApplicationConfig.Paths.PublishDirectory / AppSpecFile;
AbsolutePath specFileTemplate = ApplicationConfig.Paths.BuildToolsDirectory / AppSpecTemplateFile;
PrepareWebConfig(ApplicationConfig.WebConfigReplacingParams);
DeleteFile(ApplicationConfig.Paths.ApplicationOutputDirectory);
CopyDirectoryRecursively(ApplicationConfig.Paths.ApplicationOutputDirectory, ApplicationConfig.Paths.PublishDirectory / DeployAppDirectory,
DirectoryExistsPolicy.Merge, FileExistsPolicy.Overwrite);
CopyDirectoryRecursively(ApplicationConfig.Paths.BuildToolsDirectory / DeployScriptsDirectory, ApplicationConfig.Paths.TypeScriptsOutDirectory,
DirectoryExistsPolicy.Merge, FileExistsPolicy.Overwrite);
CopyFile(ApplicationConfig.Paths.BuildToolsDirectory / AppSpecTemplateFile, ApplicationConfig.Paths.PublishDirectory / AppSpecFile, FileExistsPolicy.Overwrite);
CopyDirectoryRecursively(ApplicationConfig.Paths.BuildToolsDirectory / DeployScriptsDirectory, ApplicationConfig.Paths.PublishDirectory / DeployScriptsDirectory,
DirectoryExistsPolicy.Merge, FileExistsPolicy.Overwrite);
Logger.Info($"Creating archive '{ApplicationConfig.Paths.ArchiveFilePath}'");
CompressionTasks.CompressZip(ApplicationConfig.Paths.PublishDirectory, ApplicationConfig.Paths.ArchiveFilePath);
}
async Task PublishApplicationToAws()
{
string s3bucketName = "";
IAwsCredentialsProvider awsCredentialsProvider = new AwsCredentialsProvider(null, null, "");
using S3FileManager fileManager = new S3FileManager(awsCredentialsProvider, RegionEndpoint.EUWest1);
using CodeDeployManager codeDeployManager = new CodeDeployManager(awsCredentialsProvider, RegionEndpoint.EUWest1);
Logger.Info($"AWS S3: upload artifacts to '{s3bucketName}'");
FileMetadata metadata = await fileManager.UploadZipFileToBucket(ApplicationConfig.Paths.ArchiveFilePath, s3bucketName);
Logger.Info(
$"AWS CodeDeploy: create deploy for '{ApplicationConfig.ApplicationName}' in group '{ApplicationConfig.DeploymentGroup}' with config '{DeploymentConfig}'");
CodeDeployResult deployResult =
await codeDeployManager.CreateDeployForRevision(ApplicationConfig.ApplicationName, metadata, ApplicationConfig.DeploymentGroup, DeploymentConfig);
StringBuilder resultBuilder = new StringBuilder(deployResult.Success ? "started successfully\n" : "not started\n");
resultBuilder = ProcessDeloymentResult(deployResult, resultBuilder);
Logger.Info($"AWS CodeDeploy: deployment has been {resultBuilder}");
DeleteFile(ApplicationConfig.Paths.ArchiveFilePath);
Directory.Delete(ApplicationConfig.Paths.ApplicationOutputDirectory, true);
string deploymentId = deployResult.DeploymentId;
DateTime startTime = DateTime.UtcNow;
/\* Ожидаем когда деплой завершится и выводим сообщение \*/
do
{
if(DateTime.UtcNow - startTime > TimeSpan.FromMinutes(30)) break;
Thread.Sleep(3000);
deployResult = await codeDeployManager.GetDeploy(deploymentId);
Logger.Info($"Deployment proceed: {deployResult.DeploymentInfo.Status}");
}
while (deployResult.DeploymentInfo.Status == DeploymentStatus.InProgress
|| deployResult?.DeploymentInfo.Status == DeploymentStatus.Created
|| deployResult?.DeploymentInfo.Status == DeploymentStatus.Queued);
Logger.Info($"AWS CodeDeploy: deployment has been done");
}
```
### Заключение
В итоге получился сборщик, который можно расширять за счёт собственного кода или сторонних пакетов. Конфигурация окружений вынесена во внешние файлы, таким образом легко можно добавить новое. При этом аргументы командной строки позволяют легко перенацелить приложение на определенное окружение. При большом желании можно построить свой build сервер.
Код можно улучшить, разбив некоторые этапы на отдельные Target-ы, сократить длину кода в методах, добавив возможность отключения отдельных этапов. Но цель статьи - познакомить со сборщиком Nuke .и показать использование на реальном примере. | https://habr.com/ru/post/537460/ | null | ru | null |
# Sidecar for a Code splitting
Code splitting. Code splitting is everywhere. However, why? Just because there is **too much of javascript** nowadays, and not all are in use at the same point in time.
JS is a very *heavy* thing. Not for your iPhone Xs or brand new i9 laptop, but for millions(probably billions) of *slower* devices owners. Or, at least, for your watches.
So — JS is bad, but what would happen if we **just disable it** — the problem would be gone… for some sites, and be gone "with sites" for the React-based ones. But anyway — there are sites, which could work without JS… and there is something we should learn from them...
Code splitting
==============
Today we have two ways to go, two ways to make it better, or to not make it worse:
1. Write less code
------------------
That's the best thing you can do. While `React Hooks` are letting you ship a bit less code, and solutions like `Svelte` let you generate just less code than *usual*, that's not so easy to do.
It's not only about the code, but also about *functionality* — to keep code "compact" you have to keep it "compact". There is no way to keep application bundle small if it's doing so many things (and got shipped in 20 languages).
There are ways to write *short and sound* code, and there are ways to write the opposite implementation — *the bloody enterprise*. And, you know, both are legit.
But the main issue — the code itself. A simple react application could easily bypass "recommended" 250kb. And you might spend a month optimizing it and make it smaller. "Small" optimizations are well documented and quite useful — just get `bundle-analyzer` with `size-limit` and get back in shape.
There are many libraries, which fight for every byte, trying to keep you in your limits — [preact](https://preactjs.com/) and [storeon](https://github.com/storeon/storeon), to name a few.
But our application is a bit beyond 200kb. It's closer to **100Mb**. Removing kilobytes makes no sense. Even removing megabytes makes no sense.
> After some moment it's impossible to keep your application small. It will grow bigger in time.
2. Ship less code
-----------------
Alternatively, `code split`. In other words — **surrender**. Take your 100mb bundle, and make twenty 5mb bundles from it. Honestly — that's the only possible way to handle your application if it got big — create a pack of smaller apps from it.
But there is one thing you should know right now: whatever option you choose, it's an implementation detail, while we are looking for something more reliable.
The Truth about Code Splitting
==============================
The truth about code splitting is that it's nature is **TIME SEPARATION**. You are not just *splitting* your code, you are splitting it in a way where you will **use** as little as possible in a single point of time.
Just don't ship the code you don't need right now. Get rid of it.
Easy to say, hard to do. I have a few heavy, but not adequately split applications, where any page loads like 50% of everything. Sometimes `code splitting` becomes `code separation`, I mean — you may move the code to the different chunks, but still, use it all. Recal that *"Just don't ship the code you don't need right now"*,– I *needed* 50% of the code, and that was the real problem.
> Sometimes just adding `import` here and there is not enough. Till it is not **time** separation, but only **space** separation — it does not matter at all.
There are 3 common ways to code split:
1. Just dynamic `import`. Barely used alone these days. It's more about issues with tracking a *state*.
2. `Lazy` Component, when you might postpone rendering and loading of a React Component. Probably 90% of "react code splitting" these days.
3. *Lazy* `Library`, which is actually `.1`, but you will be given a library code via React render props. Implemented in [react-imported-component](https://github.com/theKashey/react-imported-component#library-level-code-splitting) and [loadable-components](https://www.smooth-code.com/open-source/loadable-components/docs/library-splitting/). Quite useful, but not well known.
Component Level Code Splitting
------------------------------
This one is the most popular. As a per-route code splitting, or per-component code splitting. It's not so easy to do it and maintain good *perceptual results* as a result. It's death from `Flash of Loading Content`.
The good techniques are:
* load `js chunk` and `data` for a route in parallel.
* use a `skeleton` to display something similar to the page before the page load (like Facebook).
* `prefetch` chunks, you may even use [guess-js](https://github.com/guess-js/guess) for a better prediction.
* use some delays, loading indicators, `animations` and `Suspense`(in the future) to soften transitions.
And, you know, that's all about *perceptual* performance.
> Image from [Improved UX with Ghost Elements](https://blog.angularindepth.com/https-medium-com-thomasburleson-animated-ghosts-bfc045a51fba)
That doesn't sound good
=======================
You know, I could call myself an expert in code splitting — but I have my own failures.
Sometimes I could fail to reduce the bundle size. Sometimes I could fail to improve resulting performance, as long as `the _more_ code splitting you are introducing - the more you spatially split your page - the more time you need to _reassemble_ your page back`\*. It's called a **loading waves**.
* without SSR or pre-rendering. Proper SSR is a game changer at this moment.
Last week I've got two failures:
* I've lost in [one library comparison](https://github.com/mui-org/material-ui/issues/15450), as long as my library was better, but MUCH bigger than another one. I have failed to **"1. Write less code"**.
* optimize a small site, made in React by my wife. It was using route-based component splitting, but the `header` and `footer` were kept in the main bundle to make transitions more "acceptable". Just a few things, **tightly coupled** with each other skyrocketed bundle side up to 320kb(before gzip). There was nothing important, and nothing I could really remove. **A death by a thousand cuts**. I have failed to **Ship less code**.
> React-Dom was 20%, core-js was 10%, react-router, jsLingui, react-powerplug… 20% of own code… We are already done.
The solution
------------
I've started to think about how to solve my problem, and why *common solutions* are not working properly for my use case.
> What did I do? I've listed all crucial location, without which application would not work at all, and tried to understand why I have the rest.
It was a surprise. But my problem was in CSS. In vanilla CSS transition.
Here is the code
* a *control* variable — `componentControl`, eventually would be set to something `DisplayData` should display.
* once value is set — `DisplayData` become visible, changing `className`, thus triggering fancy transition. Simultaneusly `FocusLock` become active making `DisplayData` a **modal**.
```
{componentControl.value && }
// ^ it's does not exists. Also dead
// ^ that is just not visible, but NOT dead
```
I would like to code split this piece as a whole, but this is something I could not do, due to two reasons:
1. the information should be visible immediately, once required, without any delay. A business requirement.
2. the information "chrome" should exist before, to property handle transition.
This problem could be partially solved using [CSSTransitionGroup](https://github.com/reactjs/react-transition-group) or [recondition](https://github.com/theKashey/recondition). But, you know, fixing *one code* adding *another code* sounds weird, even if actually *enought*. I mean adding more code could help in removing even more code. But… but...
> There should be a better way!
TL;DR — there are two key points here:
* `DisplayData` has to be **mounted**, and exists in the DOM prior.
* `FocusLock` should also exist prior, not to cause `DisplayData` remount, but it's **brains are not needed** in the beginning.
---
So let's change our mental model
Batman and Robin
================
Let assume that our code is Batman and Robin. Batman can handle most the bad guys, but when he can't, his sidekick Robin comes to the rescue..
> Once again Batman would engage the battle, Robin will arrive later.
This is Batman:
```
+
- {componentControl.value && }
+
+
```
This is his sidekick, Robin::
```
-
+ {componentControl.value && }
-
-
```
Batman and Robin could form a *TEAM*, but they actually, are two different persons.
And don't forget — we are still talking about **code splitting**. And, in terms of code splitting, where is the sidekick? Where is Robin?
> in a sidecar. Robin is waiting in a **sidecar chunk**.
Sidecar
=======
* `Batman` here is all visual stuff your customer must see as soon as possible. Ideally instantly.
* `Robin` here is all logic, and fancy interactive features, which may be available a second after, but not in the very beginning.
It would be better to call this a **vertical code splitting** where code branches exist in a parallel, in opposite to a common **horizontal code splitting** where code branches are *cut*.
In [some lands](https://github.com/respond-framework/rudy), this trio was known as `replace reducer` or other ways to lazy load redux logic and side effects.
In [some other lands](https://developers.facebook.com/videos/2019/building-the-new-facebookcom-with-react-graphql-and-relay/), it is known as `"3 Phased" code splitting`.
> It's just another separation of concerns, applicable only to cases, where you can defer loading some part of a component, but not another part.
> image from [Building the New facebook.com with React, GraphQL and Relay](https://developers.facebook.com/videos/2019/building-the-new-facebookcom-with-react-graphql-and-relay/), where `importForInteractions`, or `importAfter` **are the `sidecar`**.
And there is an **interesting** observation — while `Batman` is more valuable for a customer, as long as it's something customer might *see*, he is always in shape… While `Robin`, you know, he might be a bit *overweight*, and require much more bytes for living.
As a result — Batman alone is something much be bearable for a customer — he provides more value at a lower cost. You are my hero Bat!
What could be moved to a sidecar:
---------------------------------
* majority of `useEffect`, `componentDidMount` and friends.
* like all *Modal* effects. Ie `focus` and `scroll` locks. You might first display a modal, and **only then** make Modal *modal*, ie "lock" customer's attention.
* Forms. Move all logic and validations to a sidecar, and block form submission until that logic is loaded. The customer could start filling the form, not knowing that it's only `Batman`.
* Some animations. A whole `react-spring` in my case.
* Some visual stuff. Like [Custom scrollbars](https://github.com/theKashey/React-stroller), which might display fancy scroll-bars a second later.
Also, don't forget — Every piece of code, offloaded to a sidecar, also offload things like core-js poly- and ponyfills, used by the removed code.
Code Splitting can be smarter than it is in our apps today. We must realize there is 2 kinds of *code* to split: 1) visual aspects 2) interactive aspects. The latter can come a few moments later. `Sidecar` makes it seamless to split the two tasks, giving the *perception that everything loaded faster*. And it will.
The oldest way to code split
----------------------------
While it may still not be quite clear when and what a `sidecar` is, I'll give a simple explanation:
> `Sidecar` is **ALL YOUR SCRIPTS**. Sidecar is the way we *codesplit* before all that frontend stuff we got today.
I am talking about Server Side Rendering(**SSR**), or just plain **HTML**, we all were used to just yesterday. `Sidecar` makes things as easy as they used to be when pages contained HTML and logic lived separately in embeddable external scripts (separation of concerns).
We had HTML, **plus** CSS, **plus** some scripts inlined, **plus** the rest of the scripts extracted to a `.js` files.
`HTML`+`CSS`+`inlined-js` were `Batman`, while external scripts were `Robin`, and the site was able to function without Robin, and, honestly, partially without Batman (he will continue the fight with both legs(inlined scripts) broken). That was just yesterday, and many "non modern and cool" sites are the same today.
---
If your application supports SSR — try to **disable js** and make it work without it. Then it would be clear what could be moved to a sidecar.
If your application is a client-side only SPA — try to imagine how it would work, if SSR existed.
> For example — [theurge.com](https://theurge.com/), written in React, is fully functional **without any js enabled**.
There is a lot of things you may offload to a sidecar. For example:
* comments. You might ship code to `display` comments, but not `answer`, as long as it might require more code(including WYSIWYG editor), which is not required initially. It's better to delay a *commenting box*, or even just hide code loading behind animation, than delay a whole page.
* video player. Ship "video" without "controls". Load them a second later, them customer might try to interact with it.
* image gallery, like `slick`. It's not a big deal to **draw** it, but much harder to animate and manage. It's clear what could be moved to a sidecar.
> Just think what is essential for your application, and what is not quite...
Implementation details
======================
(DI) Component code splitting
-----------------------------
The simplest form of `sidecar` is easy to implement — just move everything to a sub component, you may code split using an "old" ways. It's almost a separation between Smart and Dumb components, but this time Smart is not *contaniting* a Dumb one — it's opposite.
```
const SmartComponent = React.lazy( () => import('./SmartComponent'));
class DumbComponent extends React.Component {
render() {
return (
// <-- move smart one inside
// <-- the "real" stuff is here
}
}
```
That also requires moving *initialization* code to a Dumb one, but you are still able to code-split the *heaviest* part of a code.
> Can you see a `parallel` or `vertical` code splitting pattern now?
useSidecar
----------
[Building the New facebook.com with React, GraphQL and Relay](https://developers.facebook.com/videos/2019/building-the-new-facebookcom-with-react-graphql-and-relay/), I've already mentioned here, had a concept of `loadAfter` or `importForInteractivity`, which is quite alike sidecar concept.
In the same time, I would not recommend creating something like `useSidecar` as long you might intentionally try to use `hooks` inside, but code splitting in this form would break *rule of hooks*.
Please prefer a more declarative component way. And you might use `hooks` inside `SideCar` component.
```
const Controller = React.lazy( () => import('./Controller'));
const DumbComponent = () => {
const ref = useRef();
const state = useState();
return (
<>
)
}
```
Prefetching
-----------
Dont forget — you might use [loading priority hinting](https://medium.com/webpack/link-rel-prefetch-preload-in-webpack-51a52358f84c) to preload or prefetch `sidecar` and make it shipping more transparent and invisible.
Important stuff — prefetching scripts would load it via **network**, but not execute (and spend CPU) unless it actually required.
SSR
---
Unlike *normal* code splitting, no special action is required for SSR. `Sidecar` might not be a part of the SSR process and not required before `hydration` step. It's could be postponed "by design".
Thus — feel free to use `React.lazy`(ideally something **without** `Suspense`, you don't need any failback(loading) indicators here), or any other library, with, but better without SSR support to *skip* sidecar chunks during SSR process.
The bad parts
=============
But there are a few bad parts of this idea
Batman is not a production name
-------------------------------
While `Batman`/`Robin` might be a good mind concept, and `sidecar` is a perfect match for the technology itself — there is no "good" name for the `maincar`. There is no such thing as a `maincar`, and obviously `Batman`, `Lonely Wolf`, `Solitude`, `Driver` and `Solo` shall not be used to name a non-a-sidecar part.
Facebook have used `display` and `interactivity`, and that might be the best option for all of us.
> If you have a good name for me — leave it in the comments
Tree shaking
------------
It's more about the separation of concerns from *bundler* point of view. Let's imagine you have `Batman` and `Robin`. And `stuff.js`
* `stuff.js`
```
export * from `./batman.js`
export * from `./robin.js`
```
Then you might try *component based* code splitting to implement a sidecar
* `main.js`
```
import {batman} from './stuff.js'
const Robin = React.lazy( () => import('./sidecar.js'));
export const Component = () => (
<>
// sidecar
// main content
)
```
* `sidecar.js`
```
// and sidecar.js... that's another chunk as long as we `import` it
import {robin} from './stuff.js'
.....
```
In short — the code above would work, but will not do "the job".
* if you are using only `batman` from `stuff.js` — tree shaking would keep only it.
* if you are using only `robin` from `stuff.js` — tree shaking would keep only it.
* **but** if you are using both, even in different chunks — both will be bundled in a **first** occurrence of `stuff.js`, ie the **main bundle**.
> Tree shaking is not code-splitting friendly. You have to separate concerns by files.
Un-import
---------
Another thing, forgotten by everybody, is the cost of javascript. It was quite common in the jQuery era, the era of `jsonp` payload to load the script(with `json` payload), get the payload, and **remove** the script.
> Nowadays we all `import` script, and it will be forever imported, even if no longer needed.
As I said before — there is too much JS, and sooner or later, with *continuous navigation* you will load all of it. We should find a way to un-import no longer need chunk, clearing all internal caches and freeing memory to make web more reliable, and not to crush application with out of memory exceptions.
Probably the ability to `un-import` (webpack [could do it](https://github.com/theKashey/wipeWebpackCache)) is one of the reasons we should stick with *component-based* API, as long as it gives us an ability to handle `unmount`.
So far — ESM modules standards have nothing about stuff like this — nor about cache control, nor about reversing import action.
Creating a sidecar-enabled Library
----------------------------------
By today there is only one way to create a `sidecar`-enabled library:
* split your component into parts
* expose a `main` part and `connected` part(not to break API) via `index`
* expose a `sidecar` via a separated entry point.
* in the target code — import the `main` part and the `sidecar` — tree shaking should cut a `connected` part.
This time tree shaking should work properly, and the only problem — is how to name the `main` part.
* `main.js`
```
export const Main = ({sidecar, ...props}) => (
{sidecar}
....
);
```
* `connected.js`
```
import Main from './Component';
import Sidecar from './Sidecar';
export const Connected = props => (
}
{...props}
/>
);
```
* `index.js`
```
export * from './Main';
export * from './Connected';
```
* `sidecar.js`
```
import * from './Sidecar';
```
In short, the change could be represented via a small comparison
```
//your app BEFORE
import {Connected} from 'library'; //
// -------------------------
//your app AFTER, compare this core to `connected.js`
import {Main} from 'library';
const Sidecar = React.lazy(import( () => import('library/sidecar')));
// ^ all the difference ^
export SideConnected = props => (
}
{...props}
/>
);
// ^ you will load only Main, Sidecar will arrive later.
```
Theoretically `dynamic import` could be used inside node\_modules, making *assemble process* more transparent.
> Anyway — it's nothing more than `children`/`slot` pattern, so common in React.
The future
==========
`Facebook` proved that the idea is right. If you haven't seen that video — do it right now. I've just explained the same idea from a bit different angle (and started writing this article a week before F8 conference).
Right now it requires some code changes to be applied to your code base. It requires a more explicit separation of concerns to actually separate them, and let of codesplit not horizontally, but vertically, shipping *lesser* code for a *bigger* user experience.
`Sidecar`, probably, is the only way, except old school SSR, to handle BIG code bases. Last chance to ship a minimal amount of code, when you have a lot of it.
> It could make a BIG application smaller, and a SMALL application even more smaller.
10 years ago the medium website was "ready" in 300ms, and was *really* ready a few milliseconds after. Today seconds and even more than 10 seconds are the common numbers. What a shame.
Let's take a pause, and think — how we could solve the problem, and make UX great again...
Overall
=======
* Component code splitting is a most powerful tool, giving you the ability to *completely* split something, but it comes with a cost — you might not display anything except a blank page, or a *skeleton* for a while. That's a horizontal separation.
* Library code splitting could help when component splitting would not. That's a horizontal separation.
* Code, offloaded to a sidecar would complete the picture, and may let you provide a far better user experience. But would also require some engineering effort. That's a vertical separation.
**Let's have a conversation about this**.
Stop! So what about the problems you tried to solve?
----------------------------------------------------
Well, that was only the first part. **We are in the endgame now**, it would take a few more weeks to write down the second part of this proposal. Meanwhile… get in the sidecar! | https://habr.com/ru/post/450942/ | null | en | null |
# PHP-Дайджест № 80 – интересные новости, материалы и инструменты (14 – 28 февраля 2016)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [Энди Гутманс покидает Zend](http://andigutmans.com/2016/02/24/starting-a-new-journey/) — Один из основателей Zend и до 2015 года ее исполнительный директор, Энди Гутманс, заявил, что покидает компанию.
* [Slim 3.2.0](http://www.slimframework.com/2016/02/25/slim-3.2.0.html)
* [Prophecy 1.6](https://github.com/phpspec/prophecy/) — Обновление популярного инструмента для создания тестовых двойников.
### PHP
* [RFC: Generic arrays](https://wiki.php.net/rfc/generic-arrays) — Дополнение к [RFC о генериках](https://wiki.php.net/rfc/generics). Предлагается реализовать типизированные массивы:
```
$counts = array(); // array
$counts["kittens"] = 12;
```
* [RFC: Deprecations for PHP 7.1](https://wiki.php.net/rfc/deprecations_php_7_1) — В документе собран список возможностей, которые предлагается сделать устаревшими в PHP 7.1 и удалить полностью не позднее PHP 8. Список будет пополняться.
* [RFC: Callable Constructors](https://wiki.php.net/rfc/callableconstructors) — Предлагается сделать возможным вызов конструктора в callable структурах. Например:
```
$fn = "Foo::__construct";
$object = $fn();
```
будет равносильно
```
$object = new Foo();
```
### Инструменты
* [bouiboui/tissue](https://github.com/bouiboui/tissue) — Библиотека позволяет создавать Issue на Github прямо из исключений в коде.
* [PHPDocker.io](http://phpdocker.io/) — Аналог [puphpet.com](https://puphpet.com/), позволяет генерировать конфиг для поднятия окружения на основе Docker.
* [unicodeveloper/laravel-hackathon-starter](https://github.com/unicodeveloper/laravel-hackathon-starter) — Шаблонное PHP-приложения на основе Laravel для быстрого создания прототипов.
* [JBZoo/Utils](https://github.com/JBZoo/Utils) — Хелперы на каждый день.
* [JBZoo/Data](https://github.com/JBZoo/Data) — ArrayObject как замена обычного массива. Удобен для работы с конфигами.
* [phpthinktank/blast-orm](https://github.com/phpthinktank/blast-orm) — Простая ORM на основе Doctrine 2 DBAL.
* [wayneashleyberry/phplint](https://github.com/wayneashleyberry/phplint) — JS-обертка над стандартным php-линтером для параллельного выполнения.
* [WellCommerce/WellCommerce](https://github.com/WellCommerce/WellCommerce) — E-Commerce решение на базе Symfony 3.
* [phpqatools.org](http://phpqatools.org/) — Подборка инструментов для тестирования в PHP.
* [mpyw/co](https://github.com/mpyw/co) — Простой асинхронный cURL на основе генераторов.
* [thephpleague/skeleton](https://github.com/thephpleague/skeleton) — Шаблон репозитория для PHP-пакета.
* [Teh Playground!](https://beta.tehplayground.com/) — Песочница для быстрого прототипирования и тестирования кусков PHP-кода в браузере.
### Материалы для обучения
* ##### Symfony
+ [Руководство по Symfony — Routing](https://gnugat.github.io/2016/02/17/ultimate-symfony-routing.html)
+ [Руководство по Symfony — Dependency Injection](https://gnugat.github.io/2016/02/24/ultimate-symfony-dependency-injection.html)
+ [Асинхронные контроллеры в Symfony](https://www.symfony.fi/entry/going-async-in-symfony-controllers)
+ [Изоморфные React приложения на Symfony и Webpack](http://nacho-martin.com/symfony-react.html)
+  [Symfony и ElasticSearch](https://www.youtube.com/watch?v=vfA9nv7Mmsw&feature=youtu.be)
+  [Микрофреймворк Symfony](http://devacademy.ru/posts/mikrofrieimvork-symfony/)
+  [Инициализируемые контроллеры в Symfony и работа с аннотациями](https://habrahabr.ru/post/277465/)
* ##### Yii
+ [vesnateam/sandstorm](https://github.com/vesnateam/sandstorm) — Веб-интерфейс для работы с миграциями.
+ [Компонент командной шины для Yii 2](https://github.com/cherifGsoul/yii2-tactician)
+  [SEO-сервис на Yii2: Организация бэкенда и переносимых модулей](http://www.elisdn.ru/blog/85/seo-service-on-yii2-reusing-of-modules)
+  [Установка и настройка Yii2 на виртуальном хостинге](https://habrahabr.ru/post/277209/)
* ##### Laravel
+ [EloquentJs](http://parsnick.github.io/eloquentjs/) — Инструмент состоит из клиентской и серверной частей и позволяет в бразуере по сути использовать ORM Laravel.
+ [Использование Laravel API с помощью AngularJS](http://www.sitepoint.com/how-to-consume-laravel-api-with-angularjs/)
+ [Создаем API на Laravel с использованием JWT](http://www.sitepoint.com/how-to-build-an-api-only-jwt-powered-laravel-app/)
+ [Что такое фасады в Laravel 5.0](http://code.tutsplus.com/tutorials/what-are-laravel-50-facades--cms-25347)
+  [Создаем социальную сеть на Laravel с нуля](https://www.youtube.com/playlist?list=PL55RiY5tL51oloSGk5XdO2MGjPqc0BxGV)
* [Повышаем производительность PHP 7 с помощью NGINX, часть I](https://www.nginx.com/blog/maximizing-php-7-performance-with-nginx-part-i-web-serving-and-caching/)
* [ActiveRecord](http://shawnmc.cool/activerecord) — Подробно о паттерне для работы с БД.
* [Composer против Linux-дистрибутивов](http://www.garfieldtech.com/blog/composer-distribution-mental-model) — Larry Garfield пишет о проблеме, которую недавно [подняли в проекте Gentoo](https://wiki.gentoo.org/wiki/Project:PHP/The_Composer_problem): о различиях между пакетами Composer и системными библиотеками общего пользования.
* [Как безопасно хранить пароль в 2016 году](https://paragonie.com/blog/2016/02/how-safely-store-password-in-2016)
* [Безопасная кроссдоменная аутентификация](https://paragonie.com/blog/2016/02/one-login-rule-them-all-seamless-and-secure-cross-domain-authentication)
* [Приложение в 100 строк кода для определения породы собаки по фото](http://www.sitepoint.com/building-microsofts-what-dog-ai-in-under-100-lines-of-code/) — Используется API [Diffbot](https://www.diffbot.com/).
* [Туториал по созданию пулл-реквеста на реальном примере](http://www.sitepoint.com/contributing-to-open-source-gatekeeper-case-study/)
* [Шпаргалка по регулярным выражениям](https://github.com/niklongstone/regular-expression-cheat-sheet)
* [Итак, вы хотите написать менеджер пакетов](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527#.40tlam5vx) — О том как устроены менеджеры пакетов, в том числе Composer.
* [Устанавливаем XHProf и XHGui для профайлинга PHP-приложений на Ubuntu 14.04](https://www.digitalocean.com/community/tutorials/how-to-set-up-xhprof-and-xhgui-for-profiling-php-applications-on-ubuntu-14-04)
* [10 Years Of Zend Framework](http://weierophinney.github.io/2015-10-22-ZF3/#/) — Слайды доклада об архитектуре Zend Framework 3.
* [Взлом криптосистемы в CodeIgniter < 2.2](https://kivikakk.ee/cryptography/2016/02/20/breaking-homegrown-crypto.html)
*  [PHP Управление строками](http://blweb.ru/blog/php-upravlenie-strokami) — Как устроены строки в PHP, а также об отличиях реализаций в PHP 5 и PHP 7. Прислал [z17](https://habrahabr.ru/users/z17/).
*  [Принципы программирования — Часть 4: Сообщения](http://haru-atari.com/blog/12/programming-guidelines-part-4-messages) — Прислал [haruatari](https://habrahabr.ru/users/haruatari/).
*  [“Исключительный” код – Часть 2](http://anton.shevchuk.name/php/exceptional-code-part-2/)
*  [Как создать свой собственный Dependency Injection Container](https://habrahabr.ru/post/278049/)
*  [DI, PHPUnit и setUp](https://habrahabr.ru/post/277867/)
*  [Неожиданное поведение openssl\_random\_pseudo\_bytes() приводящее к фатальной потере криптостойкости](https://habrahabr.ru/post/277779/)
*  [Go с точки зрения PHP программиста](https://habrahabr.ru/post/277987/)
*  [Архитектура чистого кода и разработка через тестирование в PHP](https://habrahabr.ru/company/mailru/blog/277543/)
### Аудио и видеоматериалы
*  [Событийная архитектура для микросервисов](https://nomadphp.com/2016/02/22/event-driven-architecture-for-microservices/)
*  [PHP Roundtable #038: RFC Show & Tell](https://www.phproundtable.com/episode/proposed-features-of-php-71) — Видеоподкаст с авторами RFC о предложениях для PHP 7.1.
*  [PHP Roundtable #040: Graph Databases](https://www.phproundtable.com/episode/using-graph-databases-in-php)
### Занимательное
* [PSR+-04](https://github.com/fig-php/PHP-FIG-PSRs/blob/master/PSR%2B-04.markdown) — Альтернативный стандарт кодирования PSR (PHP Sadism Requirement).
* [gabrielrcouto/php-terminal-gameboy-emulator](https://github.com/gabrielrcouto/php-terminal-gameboy-emulator) — Эмулятор Gameboy на PHP.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Присылайте ссылки](http://bit.ly/php-digest-add-link) на интересные статьи или полезные инструменты, которых [не было в PHP-Дайджестах](http://pronskiy.github.io/php-digest/), и ваше имя будет рядом с присланной ссылкой в выпуске.
[Прислать ссылку](http://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 79](https://habrahabr.ru/company/zfort/blog/277197/) | https://habr.com/ru/post/278137/ | null | ru | null |
# Разработка веб-приложений на встраиваемом портале
Java порталы это особый класс веб-приложений позволяющий разрабатывать достаточно сложные и при том модульные информационные системы, которые напоминают Системы Управления Содержимым (CMS), но для корпоративного сектора. Это подразумевает, что в них обычно заложена возможность работы с иерархиями страниц, приложений, пользователей, процессов, поддерживается интернационализация и есть средства интеграции в корпоративную информационную инфраструктуру.
На рынке этих систем существуют коммерческие продукты от таких известных компаний как Oracle, SAP, IBM (теперь HCL Technologies Ltd), Red Hat JBoss, и кроме того есть также портал Liferay имеющий приличную опенсорс версию, а также образовательные и другие тематически-ориентированные портальные системы, есть и не вполне порталы, но информационные системы, поддерживающие технологии порталов такие как DMS Alfresco. Поддерживающие означает даже, что в теории приложения разработанные для одной системы можно устанавливать в другую, но на деле это было не совсем так. Производители добавляли свои возможности несовместимые с другими, что оставляло эту не имеющую аналогов фичу в нереализованных.
Многие специалисты недооценивают важность совместимости технологий и стандартов. Вообще, организация разработки для порталов долгое время могла быть непростым делом, т.к. многие коммерческие вендоры продолжают жить в своих закрытых мирках и вообще зарабатывать на решении проблем разработчиков. Сами порталы ориентированные на работу с солидной нагрузкой также имели приличные по прежним временам системные требования. Ситуация может значительно улучшится с выходом стандарта приложений Portlet 3.0 и сегодня мы попробуем наладить универсальный и при том относительно комфортный процесс разработки приложений для портальных систем.
---
С точки зрения пользователей порталы обычно позволяют легко управлять большим количеством сайтов их ресурсов и приложений не выходя из “админки”, гибко настраивать отображение материалов на страницах без кодирования. В то же время для разработчиков портальные системы остаются платформой с приличным стеком технологий.
Как и другие java технологии портальные приложения хорошо стандартизированы. Есть стандарты Portlets 1.0 по признаку поддержки которого можно причислить веб системы к джава порталам, также многие развитые порталы поддерживают Portlets 2.0, и пока еще не многие относительно новый стандарт Portlets 3.0.
Третья версия стандарта на приложения портлетов привносит много долгожданных фич для приложений, которые позволяют создавать веб-приложения для порталов так-же просто и легко как не знаю прямо уже что;). Возможно стартеры проектов npm или spring-boot тут будут подходящей аналогией. При этом сама по себе концепция портлетов т.е. виджетов размещаемых на одной странице всегда была несколько сложнее монолитных или SPA приложений, поэтому и разработка портлетов выходящих за рамки “одного окна” была сложнее. И вот третья версия многие эти сложности устраняет, позволяя модульно и переиспользуемо управлять фронтенд ресурсами приложения. Говоря конкретнее: теперь можно поделить один метод отдающий JSON или файлы между портлетами, можно контролировать загрузку разных джаваскриптов с помощью механизмов портала таким образом, что они не будут загружены дважды, объявлять портлеты и их методы теперь можно декораторами без всех этих сложных для новичка xml-ей, но совместимость с этими конфигурациями продолжает работать.
Поддержка стандартов разработки порталов позволяет устанавливать приложения написанные под один портал на другой, а также запускать на сервере с порталом всевозможные веб-приложения на джаве позволяя выстраивать всевозможные архитектуры включая сервисно-клиентные. Т.е. в портале заработают и классические сервлеты и различные java фреймворки поддерживающие сервлетные контейнеры, такие как Spring, Struts, Faces, Jersey и многие прочие. А на некоторых порталах можно даже использовать другие языки программирования навроде PHP или Ruby.
Также порталы часто поддерживают технологию WSRP позволяющую приложения управляемые одним порталом показывать на любом другом настроенным на поддержку этой технологии.
Некоторые портальные системы кажутся достаточно тяжелыми по требовательности к ресурсам. Разворачивание может потребовать от 4-х и более гигабайт оперативной памяти. Их конфигурации рассчитаны на кластеризацию и разрабатывать для них без специальных инструментов от вендора выходит не очень удобно.
Но если придерживаться стандартов портальной и Java разработки, то можно запускать их на любом поддерживаемом портале и для разработки в этом случае может сгодиться достаточно простой и “легкий” портал.
Таким порталом является Apache Pluto, который выполняет роль основы для многих портальных систем и референсной реализации, т.е. образцом реализации стандартов и технологий для производителей.
Чтобы получить самые актуальные версии соберем все из исходных кодов.
Далее мы будем использовать консольные команды которые работают в Unix-like операционных системах или в Windows если включить при установке дистрибутива git поддержку shell утилит. Убедившись что git установлен и откликается в cmd.exe или другом вашем терминале склонируем проект с гитхаба
```
git clone https://github.com/apache/portals-pluto
```
Собираем дистрибутив. Для того, чтобы все наверняка собралось потребуется джава какой-нибудь стабильной версии, например 8ой и установленный сборщик ant. Проще конечно это все будет поставить пакетной системой дистрибутива вашей ОС. Для запуска сборки переходим в каталог с проектом и выполняем команду
```
mvn package
```
для сборки и для упаковки дистрибутива
```
ant -f dist-build.xml -DpackageOnly=true
```
также лучше добавить флаг -DincludeDemos=true для включения примеров в бандл, но у меня также потребовалось подкорректировать билд-файл демо подпроектов чтобы имя дистрибутива не содержало версий, в demo/pom.xml в секцию build я добавил настройку
```
${project.name}
```
на Windows мне также пришлось и добавить пропуск плагина в pom.xml,т.к. он где-то заваливался
```
org.apache.maven.plugins
maven-gpg-plugin
1.6
true
```
После успешного завершения сборки в подкаталоге проекта **target/dist** появится файл дистрибутива, примерно такого вида. Это самодостаточный дистрибутив портала установленного в контейнер, т.е. сервер приложений готовый к развертыванию.
**pluto-3.1.1-SNAPSHOT-bundle.tar.bz2**
Теперь у нас есть собственный дистрибутив портала.
Мы его распакуем куда удобно, например рядом на с:\projects
```
cd c:\projects
tar xvjf c:\portals-pluto\pluto-3.1.1-SNAPSHOT-bundle.tar.bz2
```
Перейдем в распакованный каталог и запустим на наш сервер
```
cd pluto-3.1.1-SNAPSHOT
bin\startup.bat
```
или startup.sh если вы на юниксе.
Портал будет запускаться некоторое время, которое прямо зависит от количества установленных в него приложений.
На всякий случай лучше посматривать за логами, это можно делать вот такой командой:
```
tail logs\catalina-дата.out -f
```
в Windows они будут отображаться прямо во вновь открывшемся окне.
появление сообщения вида
```
org.apache.catalina.startup.Catalina.start Server startup
```
говорит нам о том, что сервер готов служить, после чего мы можем открыть в браузере адрес
<http://localhost:8080/pluto>
Логин - pluto и такой же пароль.
Слева будут ссылки на страницы с примерами различных приложений.
Чтобы быть готовым это увидеть, надо понимать, что Apache Pluto это демонстрационная, можно сказать, академическая разработка, он не претендует на продуктовое совершенство и привлекательность для пользователей, которое вы можете найти в других системах таких как Liferay или WebSphere/HCL DXP.
Страницы можно конфигурировать через панель управления в разделе Pluto Admin, добавляя и убирая страницы и размещая на них портлеты.
<http://localhost:8080/pluto/portal/Pluto%20Admin>
Код этих примеров можно посмотреть в каталоге demo, импортируя их в среду разработки, собирая и деплоя на портал копируя .war файлы в подкаталог **webapps/**.
Теперь создадим новое приложение из архетипа. Для этого понадобиться установленный maven, может быть даже довольно актуальной версии. Для windows установка примерно сводится к распаковке дистрибутива с сайта и прописывании переменной M2\_HOMEв окружения и добавления путя M2\_HOME\bin в Path.
```
cd projects
mvn archetype:generate -DarchetypeGroupId=org.apache.portals.pluto.archetype -DarchetypeArtifactId=mvcbean-jsp-portlet-archetype -DarchetypeVersion=3.1.0 -DgroupId=com.mycompany -DartifactId=hello-portlet
```
Если залипло или что-то спрашивает нажимайте Enter.
Лучше в pom.xml сразу добавить имя выходного файла без версии.
```
${project.name}
```
Соберем проект и задеплоим.
Данный архетип поддерживает сборку под разные порталы при помощи профилей, т.е. чтобы собирать для pluto надо указать соответствующий профиль.
```
cd hello-portlet
mvn -Ppluto package
```
Вообще говоря, это специальные сборки не всегда обязательны в разработке портальных приложений, часто специфичные для порталов конфигурации дополняют определенные стандартами параметры. Но для непростых жизненных т.е. реальных случаев профили позволяют “подсовывать” разные конфигурации для разных целевых платформ.
Если вместо **pluto** указать **liferay-cdi** или **liferay-spring**, то будет собран проект с конфигурациями и библиотеками для портала Liferay с одной из реализаций системой управления зависимостями. Т.е. в коде для нас может почти ничего не меняться т.к. у них есть унификация интерфейсов, а управляться зависимости в работающем приложении будут разными подсистемами.
После выполнения команды в **target/**’е привычно для Java-разработчика окажется .war файл.
Задеплоить приложение на портал мы можем просто скопировав .war архив в подкаталог сервера **webapps**.
Где-то через секунду в логах появятся отчеты об обнаруженном дистрибутиве и ходе его установки.
Добавим тестовую страницу и разместим на ней наш портлет.
По состоянию на момент написания статьи есть такая особенность, что отображение списка портлетов из модуля при добавлении работает в браузере Firefox, но не работает в Chrome. Похоже на какую-то диверсию, но благо пользоваться этим приходится не часто, при редеплойменте приложения лезть в настройке не надо, а достаточно просто скопировать новый .war файл в **webapps/** снова. Имейте это ввиду, я изрядно помучился в свое время, прежде чем догадался до такого изящного решения проблемы.
Портлет это то, что соответствует окошечку на портале, которое, к слову, может не иметь декораций и рисовать любой блок разметки, данных или ресурс. Кроме состояния VIEW соответствующего чаще всего некоему render методу оно может также иметь и другие, такие как EDIT, HELP и вообще любые произвольно добавленные. Но разумным наверное могло бы быть и соответствие “один экран” == “один портлет”. Т.к. портлеты городить с появлением аннотаций стало гораздо проще. Порталы дают возможность решать эту непростую задачу стандартизированным образом. Сейчас многие порталы поддерживают ЧПУ (человекопонятный адрес в строке браузера) мапинг, а также имеют интерфейсы для обратного биндинга ссылок, что может показаться уже не так просто как захардкодить все адреса в роутах, но более совершенно в целом.
Созданный в результате каталог **hello-portlet/** можно импортировать как обычный maven проект в IntelliJ IDEA. Замечательной особенностью является также и то, что мы можем использовать gradle в качестве системы сборки, т.к. его конфигурация тоже была сгенерирована. Но сегодня останемся пока на maven.
Открыв проект мы видим, что перед нами очень похожее на привычное MVC приложение на джаве.
Теперь вместо, т.е. вместе с конфигурациями используются аннотации которыми можно декорировать методы практически произвольно, связывание при этом с абстракцией портлетов происходит за счет атрибутов portletName или portletNames. Это дает несколько больше гибкости чем раньше, когда приходилось наследоваться от некоего Portlet или реализовывать его интерфейс.
Декораторы выглядят вполне знакомо:
@Inject - привычно завайрит класс-зависимость или сервис
@RenderMethod - метод для проталкивания данных в шаблон
@ActionMethod - метод для обработки GET, POST запросов “на бекенд”
@ServeResourceMethod - метод для получения данных с бекенда например в JSON для загрузки в фронтенд технологию
Для экшин-методов идентификация происходит также по actionName, а ресурсов по id.
Шаблоны и другие фронтенд ресурсы могут лежать в положенном по WAR лейауту месте, т.е. например
**src/main/webapp/resources**
Для рендер метода можно указать какой шаблон рендерить прямо параметром
```
@RenderMethod(portletNames = "HelloPortlet", include = "/WEB-INF/jsp/helloView.jsp")
```
Чтобы в шаблоне получить ссылку на ресурсный или экшин метод используют теги например так
или вот так
Это можно прямо завернуть в джаваскрипт коде в строку и использовать в rest запросах на сервер.
Значения прокидываются через **request.setAttribute** и доступны как переменные сразу если вы используете JSTL (т.е. прописана в зависимостях и в теглибах) или через доставание из контекста если просто JSP
```
<%
String ctxPath = request.getContextPath();
List settings = (List) renderRequest.getAttribute("settings");
%>
```
Тут надо осознавать, что портлет это более универсальное и переиспользуемое явление по сравнению с обычным монолитным приложением или даже модулем. И ваш портлет должен быть готов к тому, чтобы оказаться добавленным на любую страницу и даже иногда в количестве более одного экземпляра. Он не должен ломаться или глючить от такого пользовательского волюнтаризма.
Чтобы код разных портлетов и экземпляров не конфликтовал между собой и работал без перехадркоживания значений под каждый сервер, следует использовать и **contextPath** для глобальных идентификаторов в браузере т.е. id и имен переменных, а внутрепортлетную логику структурировать так чтобы она не завязывалась на глобальное, иначе говоря, была модульной и могла интегрироваться в среду.
Если ваш фронтенд фреймворк поддерживает независимую работу нескольких приложений на странице или нескольких не предполагается, то можно спокойно прикручивать его. Для лайфрея есть целый набор примеров приложений с использованием React, Angular, Vue и других популярных фреймворков. Но я бы рекомендовал использовать для разработки фронтенда технологии веб-компонентов, т.к. они позволяя использовать современные технологии модульности дают возможность структурировать код разделенным на компоненты. Моя библиотечка skinny-widgets (<https://www.npmjs.com/package/skinny-widgets>) дает некоторый набор готовых виджетов написанных на веб-компонентах и поддерживает современные стандарты разработки включая модульность и темизацию.
Портлеты установленные в портал работают в некоторой изоляции друг от друга даже когда находятся на одной странице и для получения данных из GET параметров запроса в контексте портлета надо объявлять public render parameters в аннотациях портлета или метода
```
@PortletConfiguration(portletName="portlet1", publicParams = {"categoryId"},
… { другие параметры }
)
```
При этом для POST данных такого делать не нужно, переданный параметр с бекенд стороны можно получить через такой интерфейс.
```
RenderURL renderURL = resp.createRenderURL();
MutableRenderParameters renderParams = renderURL.getRenderParameters();
String idString = renderParams.getValue(name);
```
На момент проверки эта возможность не работала еще в Liferay и для кроссплатформенности я делал обертку с фолбеком (в конце статьи будет ссылка на проект с этим кодом) на выдергивание из контекста как раньше, ссылку на которое вы найдете в конце статьи.
А для данных multipart форм есть специальный метод
```
Part part = request.getPart("image");
```
Портлеты “из коробки” поддерживают интерационализацию, т.е вы можете загружать переводы под локаль из ресурсных файлов, которые также можно определить в @PortletConfiguration, там же определяются и состояния портлетов и другие их параметры.
Кроме того, в портлетах есть понятие PortletPreferences, т.е. интерфейса для настроек портлета которые могут изменяться администраторами в соответствующих диалогах. В Apache Pluto эти параметры не сохраняются между рестартами, но в Liferay очень активно используются и там даже есть свои диалоговые примочки для работы с ними.
Все это декларируется там же в @PortletConfiguration и соответствует содержимому portlet.xml, которым делалась конфигурация для предыдущих версий портлетов и даже объединяется с ним если вы решили использовать такие конфигурации.
Если возникают трудности вида “как это сделать для портала”, очень полезно будет посмотреть примеры код которых находится в подкаталоге **demo/** репозитория портала с которого мы начали изучение. Там вы найдете ответы на типовые вопросы вроде “как работать с формами и аплоадом ?”, “как контролируемо подключать фронтенд файлы ?”.
Если выходишь за их рамки, т.е. прикручиваешь разные библиотеки и фреймворки, бывает вылазят разного рода ошибки, одна из которых касается встроенного инжектора weld, решение этой проблемы заключается в том чтобы скопировать джарку jandex версии например 1.2.2.Final в подкаталог **lib/** сервера.
Портлет это фронтенд приложение и оно желательно должно быть легким, что очень хорошо ложится на популярные нынче микросервисную или микрофронтендные архитектуры. Поэтому весь процессинг и логику лучше не собирать в портлете, а вынести в сервисы, портал в свою очередь позволит вам модульно управлять фронтендами для этих сервисов сохраняя возможности взаимодействия между приложениями.
Пример готового модульного проекта интернет-магазинчика построенного с использованием сервисной архитектуры можно найти тут: <http://bitbucket.org/finistmart>
Он состоит из нескольких портретных проектов и сервиса на JAX-RS инкапсулирующего бизнес-логику и работающего как с СУБД MySQL так и c Postgres.
Предупреждение: я там не делал рефакторинга еще и кодревью проводить не обязательно;) Там есть например дублирование которое уйдет в перспективе в разделяемые библиотеки.
Возможно, я еще опишу пошагово как создавать такие приложения в отдельной статье.
Все это добро можно задеплоить в один Pluto или Liferay сервер и вести разработку на относительно скромной по современным меркам конфигурации ПК (мне хватает ноута i7 2Ггц U с 8 Gb RAM на СУБД, сервер приложений даже когда это liferay, среду разработки со всеми этими проектами в дебаге, браузер хром и плеер музыки;) и деплоить в кластер на разные ноды.
Дистрибутив Liferay, который не надо собирать из исходников, а можно просто распаковать и запустить проще всего скачивается из раздела файлов одноименного проекта на sourceforge.net
В Liferay портлетные варки закидываются в **deploy/**, а сервелетные в **tomcat-x.y.z/webapps** и для комфортной разработки в **portlet-ext.properties** надо добавить параметры (которые можно нагуглить) отключающие различные кеширования. После некоторой настройки, он может оказаться неплохим вариантом и для разработки. | https://habr.com/ru/post/521498/ | null | ru | null |
# Знакомьтесь с Ember Octane
Ember Octane — это новая редакция фреймворка Ember.js, а также лучший способ для команд создавать амбициозные веб-приложения.
20 декабря вышла новая версия Ember 3.15. И это Octane! Любопытно, что это значит для веб-разработки? Этот пост поможет вам сориентироваться.
Мы с гуглотранслейтом усердно старались над переводом (особенно гуглотранслейт). Добро пожаловать под кат!
Описание технических деталей (стратегии обновления, устаревшие функции, новые функции Ember Data) см. в блоге [Ember 3.15 Release (англ.)](https://blog.emberjs.com/2019/12/20/ember-3-15-released.html).
Что такое Ember Octane?
=======================
Ember всегда фокусировался на создании лучшей среды, которую люди с разными уровнями квалификации могут использовать вместе для создания веб-приложений. Octane обновляет компоненты и систему реактивности Ember, чтобы сделать их более современными и простыми в использовании. Теперь использовать Ember станет намного веселее!
Начиная с версии 3.15, разработчики Ember рекомендуют Octane для новых приложений и дополнений. Если вы создадите новое приложение, используя `ember new` с версией 3.15 или более поздней, вы получите новое приложение Octane.
Octane это fun
==============
Центральным элементом улучшений Octane являются два больших изменения в ядре Ember: новая модель компонентов и новая система реактивности.
> Для существующих приложений на Ember оба изменения полностью совместимы с существующим кодом. Обновление приложения Ember 3.14 до Ember 3.15 является совместимым изменением, как и предполагает номер версии.
Glimmer компоненты
------------------
Первое большое улучшение в Ember Octane — это компоненты Glimmer. Начиная с Ember 1.0 в Ember была однокомпонентная система, основанная на синтаксисе JavaScript, который был доступен в то время.
### До: классические Ember компоненты
Когда вы смотрите на классические компоненты, первое, что бросается в глаза это то, что вы конфигурируете «root-элемент», используя синтаксис JavaScript.
```
import Component from '@ember/component';
export default Component.extend({
tagName: 'p',
classNames: ["tooltip"],
classNameBindings: ["isEnabled:enabled", "isActive:active"],
})
```
### После: компоненты Glimmer
Компоненты Glimmer, с другой стороны, позволяют обрабатывать корневой элемент как любой другой элемент. Это существенно упрощает модель компонентов, исключая особые случаи, связанные с наличием второго API только для работы с корневым элементом компонента.
Это также означает, что вы можете создать компонент без корневого элемента, и это будет работать.
Использование модификаторов(modifiers) для повторного использования поведения DOM
=================================================================================
Второе значительное улучшение в модели компонентов Ember — это модификаторы элементов — функция, которая позволяет создавать поведение DOM многократного использования, которое не связано с каким-либо конкретным компонентом.
До: Mixins
----------
В классическом Ember, если вы хотите определить часть поведения DOM, которую вы можете повторно использовать в своем приложении, вы должны определить компонентный миксин, в котором реализованы соответствующие хуки жизненного цикла.
Например, у нас есть сторонняя библиотека, которая предоставляет функции activateTabs и deactivateTabs, каждая из которых принимает элемент. В классическом Ember вы можете написать миксин так:
```
import Mixin from '@ember/object/mixin';
export default Mixin.create({
didInsertElement() {
this._super();
activateTabs(this.element);
}
willDestroyElement() {
this._super();
deactivateTabs(this.element);
}
})
```
И тогда вы будете использовать его в таком компоненте:
```
import Component from '@ember/component';
export default Component.extend(Tabs, {
// ...
});
```
Недостатки использования миксины для композиции пользовательского интерфейса хорошо описаны во всей экосистеме JavaScript ([Mixins Considered Harmful](https://reactjs.org/blog/2016/07/13/mixins-considered-harmful.html), [Hooks are coming to Vue.js version 3.0](https://blog.logrocket.com/hooks-are-coming-to-vue/), [Declined mixin proposal for svelte](https://github.com/sveltejs/svelte/issues/1041#issuecomment-353660981), [Ember RFC: Deprecate Mixins](https://github.com/emberjs/rfcs/issues/534)). Самая большая проблема — конфликты имен. Любой метод в миксине может конфликтовать с методом в любом другом миксине, без хорошего способа разрешения конфликтов.
В контексте Ember есть еще одна проблема с использованием миксинов компонентов Ember для многократного использования поведения DOM. Если вы хотите использовать миксин `Tabs` для элемента, вам нужно превратить этот элемент в компонент с классом JavaScript, что довольно неудобно.
> Хотя мы рекомендуем избегать миксинов, вы можете использовать их в Ember 3.15. Аддоны также могут по-прежнему предоставлять вам миксины.
После: Модификаторы элемента
----------------------------
Ember Octane предоставляет новый способ повторного использования поведения DOM: модификаторы элементов. Самый простой способ написать модификатор элемента — написать функцию, которая берет элемент и что-то с ним делает. Функция может дополнительно возвращать функцию-деструктор, которая должна запускаться, когда Ember разрушает элемент.
Вот как выглядит наш миксин `Tabs` когда переопределяется как модификатор.
```
import { modifier } from 'ember-modifier';
export default modifier(element => {
activateTabs(element);
return () => deactivateTabs(element);
});
```
Согласитесь, просто!
Вы можете использовать модификатор для любого элемента, используя синтаксис модификатора элемента.
Модификаторы элементов работают с любым элементом, что означает, что вам не нужно создавать целый компонент просто для создания многократно используемого поведения DOM.
Этот способ написания модификаторов предполагает, что когда изменяются аргументы модификатора, можно запустить деструктор и запустить модификатор с нуля. Если вам нужно более детальное управление, пакет `ember-modifier` также предоставляет более продвинутый API.
Реактивность заимствованная из Glimmer
======================================
Отличительной чертой современного внешнего интерфейса является его «модель реактивности». Модель реактивности говорит вам, как определять и манипулировать данными в вашей программе, чтобы выходной DOM корректно обновлялся при внесении изменений.
Ember Octane раскрывает значительно более простую модель реактивности, называемую «отслеживаемыми (tracked) свойства».
> Модель реактивности с отслеживаемыми свойствами совместима с классической моделью реактивности. Это связано с тем, что оба API реализованы в рамках модели внутренней реактивности Ember, основанной на [Ссылках](https://github.com/glimmerjs/glimmer-vm/blob/master/guides/04-references.md) и [Валидаторах](https://github.com/glimmerjs/glimmer-vm/blob/master/guides/05-validators.md) .
До: вычисляемые свойства (computed properties) и их ограничения
---------------------------------------------------------------
В классическом Ember вы изменяете реактивные свойства, используя `set`, и любые вычисления должны быть описаны как вычисляемые поля, которые должны полностью перечислять все зависимости.
Вот пример вычисляемых полей из руководств Ember 3.14:
```
import EmberObject, { computed } from '@ember/object';
const Person = EmberObject.extend({
firstName: null,
lastName: null,
age: null,
country: null,
fullName: computed('firstName', 'lastName', function() {
return `${this.firstName} ${this.lastName}`;
}),
description: computed('fullName', 'age', 'country', function() {
return `${this.fullName}; Age: ${this.age}; Country: ${this.country}`;
})
});
let captainAmerica = Person.create({
firstName: 'Steve',
lastName: 'Rogers',
age: 80,
country: 'USA'
});
captainAmerica.description; // "Steve Rogers; Age: 80; Country: USA"
captainAmerica.set('firstName', 'Steven');
captainAmerica.description; // "Steven Rogers; Age: 80; Country: USA"
```
Такая конструкция усложняет разбиение вычисляемого свойства на более мелкие функции, поскольку ему по-прежнему необходимо перечислять все используемые им свойства независимо от того, где они используются. На практике это означает, что в классическом Ember вы нагромождаете одни вычисляемые свойства на другие, что работает, но довольно обременительно.
После: Отслеживаемые свойство (tracked properties)
--------------------------------------------------
В модели реактивности Octane, отслеживаемые свойства гораздо лаконичнее.
```
class Person {
@tracked firstName;
@tracked lastName;
@tracked age;
@tracked country;
constructor({ firstName, lastName, age, country }) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
this.country = country;
}
get fullName() {
return `${this.firstName} ${this.lastName}`;
}),
get description() {
return `${this.fullName}; Age: ${this.age}; Country: ${this.country}`;
})
}
let captainAmerica = new Person({
firstName: 'Steve',
lastName: 'Rogers',
age: 80,
country: 'USA'
});
captainAmerica.description; // "Steve Rogers; Age: 80; Country: USA"
captainAmerica.firstName = "Steven";
captainAmerica.description; // "Steven Rogers; Age: 80; Country: USA"
```
Вы начинаете с обычного класса JavaScript и аннотируете любые поля, которые могут повлиять на DOM, с помощью `@tracked`. Вам не нужно аннотировать геттеры или функции, так что вы можете разбить ваш код так, как хотите.
> Особенность модели реактивности отслеживаемых свойств заключается в том, что если вы удалите аннотацию `@tracked`, код будет работать точно так же. Единственное, что изменяется, когда вы добавляете `@tracked` это то, что если свойство изменяется, любая часть DOM, которая использовала это свойство как часть своих вычислений, будет корректно обновляться.
Внимание к документации
=======================
Octane — это больше, чем просто новые функции. Кроме того, мы уделили много внимания обновлению документации, чтобы показать пользователям, как создавать приложения в стиле Octane.
Туториал — это первый способ, которым люди учатся создавать приложения Ember. Ember 3.15 полностью обновил [туториал по Super Rentals](https://guides.emberjs.com/v3.15.0/tutorial/), переписав его в стиле Octane. Структура уроков также уточнена и обновлена.
Руководство (guides) также подверглось значительному обновлению. Теперь мы вначале рассказываем о компонентах, устранив сбивающую с толку организацию (например, разделение между шаблонами и компонентами). Новое руководство снимает акцент с контроллеров, которые менее важны в Octane. Классическая объектная модель теперь включена в раздел о миграции на Octane.
Ember Inspector стал еще лучше
==============================
Инспектор Ember — очень важная часть того, как разработчики Ember создают приложения Ember.
Мы очень гордимся тем, что на протяжении многих лет мы поддерживаем пятизвездочный рейтинг в Интернет-магазине Chrome.
Для Octane инспектор Ember обновлен для поддержки первоклассных функций Octane, включая отслеживаемые свойства и компоненты Glimmer.
Обновленный инспектор устраняет дублирующиеся понятия и устаревший язык (например, «Дерево просмотра»). Он также имеет множество визуальных улучшений, включая новую всплывающую подсказку о компонентах, которая лучше отражает идиомы Octane. Также обновляется всплывающая подсказка для компонента, которая устраняет давнюю проблему небольшими компонентами.
Начиная работу
==============
Независимо от того, являетесь ли вы новым разработчиком Ember, вернувшимся в Ember спустя много лет, или уже активным разработчиком Ember, самый быстрый и простой способ научиться создавать приложения с помощью Octane — это пройти через обновленное руководство. (От переводчика: для активных разработчиков полезным будет изучить [сравнительный Cheat Sheet](https://ember-learn.github.io/ember-octane-vs-classic-cheat-sheet/))
Экосистема аддонов Ember — это отличная часть Ember, поэтому вы захотите использовать аддоны, чтобы ускорить процесс создания вашего проекта.
[Ember Observer](https://emberobserver.com/) — это каталог для экосистемы аддонов Ember. Каждый аддон получает оценку качества на основе анализа формальных критериев, таких как наличие значимого README, имеет ли аддон автоматическую сборку, и поддерживается ли аддон более чем одним человеком. Начиная с этой недели также будет указано, является ли аддон Octane Ready.
> Большинство дополнений должны быть Octane Ready без каких-либо изменений. Ember Observer поможет сообществу заблаговременно выявлять и устранять проблемы Octane в поддерживаемых пакетах.
Немного подробнее о бесшовном взаимодействии (seamless interop)
===============================================================
В дополнение к исключению вычисленных свойств, модель реактивности Glimmer также не включает Ember Proxies или Observers. Модель реактивности Octane более мощная, чем классическая, но ее гораздо проще использовать.
Модель реактивности Octane не была бы полезна для существующих пользователей Ember, если бы было трудно использовать объекты, реализованные с использованием классической модели реактивности, из объектов, реализованных с использованием модели Octane. Поэтому мы усердно работали над тем, чтобы существующие приложения Ember могли свободно использовать классические объекты в классах, созданных с использованием отслеживаемых свойств.
```
class Contact {
@tracked person;
constructor(person) {
this.person = person;
}
get description() {
return this.person.description;
}
}
import EmberObject, { computed } from '@ember/object';
const Person = EmberObject.extend({
firstName: null,
lastName: null,
age: null,
country: null,
fullName: computed('firstName', 'lastName', function() {
return `${this.firstName} ${this.lastName}`;
}),
description: computed('fullName', 'age', 'country', function() {
return `${this.fullName}; Age: ${this.age}; Country: ${this.country}`;
})
});
let captainAmerica = new Person({
firstName: 'Steve',
lastName: 'Rogers',
age: 80,
country: 'USA'
});
let contact = new Contact(captainAmerica);
contact.description; // "Steve Rogers; Age: 80; Country: USA"
captainAmerica.set('firstName', 'Steven');
contact.description; // "Steven Rogers; Age: 80; Country: USA"
```
Поскольку эти две системы совместимы, библиотеки могут использовать систему реактивности Octane без существенных изменений в API.
Это позволяет вам переписывать существующие приложения Ember с использованием Octane модуль за модулем.
Спасибо за ваш интерес к Ember Octane
=====================================
Octane — проект, которым сообщество Ember рада поделиться с разработчиками, как новыми, так и опытными. Octane — это современный продуктивный способ создания веб-приложений, позволяющий получать удовольствие и стабильность в нашей работе.
Полное обновление API-интерфейсов Ember и документации не могло бы быть достигнуто без усилий сообщества и каждого члена [core-команд Ember](https://emberjs.com/team/). Благодарим вас за то, что вы являетесь его частью, вносите свой вклад в этот проект и продолжаете помогать Ember быть отличным выбором для веб-разработки.
> от переводчика:
>
> На русском про Ember можно спрашивать в телеграмм канале [ember\_js](https://t.me/ember_js) | https://habr.com/ru/post/482158/ | null | ru | null |
# Организация IPAM и переезд с phpIPAM в NetBox: советы и подводные камни
В [прошлой статье](https://habr.com/ru/company/rosbank/blog/654987/) я рассказал о том, как наладить кабель-менеджмент в NetBox — популярном опенсорс-инструменте для документирования инфраструктуры. В этом посте я перейду к тому, как организовать IP-адресацию и, по заявкам читателей, затрону перенос данных в NetBox из phpIPAM. Все процессы будут проиллюстрированы скриншотами NetBox версии 3.2, до которой мы обновились в тестовой среде.
### IPAM (IP-адресация) в NetBox
Ведение IPAM — это базовая функция NetBox. DCIM, может быть, нужен и не всем, но без IPAM обойтись почти невозможно. Хотя на практике я не встречал, чтобы в NetBox приходили исключительно за IPAM. Как правило, две эти функции отлично дополняют друг друга в рамках единого инструмента.
Кто-то начинает вести учет IP-адресов в Excel, но по мере усложнения сети это становится все менее удобным. NetBox же сильно облегчает задачу, потому что из коробки предлагает учет префиксов, IP-адресов и VLAN, а также разделение на VRF и даже RT. Поэтому очень удобно совмещать DCIM и IPAM, связывая в одной системе устройства и их адреса, используемые для доступа к устройствам. Это помогает при автоматизации.
А теперь обо всем по порядку.
### Иерархия IPAM в NetBox
В NetBox IP-адреса автоматически группируются по вложенности, от aggregates, которые представляют собой либо выделенные нами глобальные адреса, либо больше приватные сети. Далее aggregates распадаются на сети и подсети, которые используются для выделения IP-адресов. Всё привычно и понятно: в адресах должен быть порядок.
RIR — это провайдер, организация, ответственная за адресное пространство. Когда адреса внутренние, здесь указывается RFC-стандарт.
При создании сети в настройках важно указать, предназначена ли она для разделения на подсети или для раздачи IP-адресов. От этого зависит, как будет отображаться заполненность сети в интерфейсе NetBox. В первом случае это будет Container, во втором у сети может быть любой другой статус (например, Active).
Создавая подсеть, важно корректно указать, pool это или нет. От этого будет зависеть, раздается ли первый или последний IP-адрес.
Уже на старте следует решить, как быть с дублями. В конфигах NetBox можно настроить это поведение. Как правило, дублирование в рамках одного адресного пространства не допускается.
В таком сценарии при попытке добавления уже существующего адреса будет возникать ошибка. Стоит включить его как минимум во время переноса IP-пространства в NetBox из другой базы, если мы знаем, что там не всё точно, а желания воевать с каждым дублем нет. Так можно переехать по-быстрому, сохранив всё как есть.
В GUI NetBox также предусмотрены красивые визуализации заполненности для отслеживания свободных IP и сетей.
### VLAN группы
Это наши классические VLAN, здесь следует отметить только разницу между VLAN в группе и в общем пространстве. В последнем случае можно заводить VLAN с дублированием и NAME, и ID — NetBox не будет против помойки любых масштабов. В рамках группы дублирование запрещено как по ID, так и по NAME.
В идеальном мире всё должно быть уникально и разложено по полочкам. VLAN-группы удобно использовать в качестве L2-доменов.
### Разделения пространств VRF
По умолчанию все адресное пространство идет в global table. Но вы можете разделить таблицы маршрутизации с помощью VRF, если привыкли это делать в своей среде.
Если вы в NetBox ведете учет виртуальных машин, то есть раздел Services, здесь можно указать, какие сервисы относительно портов виртуальным машинам предоставляются. Например, какие порты предполагаются как открытые на сервере. Или SSH на железе.
### Как можно разметить пространство
В адресном пространстве должно быть легко искать сети и адреса. В IPAM могут приходить разные люди. Сетевым инженерам нужна новая сеть или адрес, безопаснику надо понять, к какому сегменту относится адрес и куда он хочет попасть. Наконец, наши интеграции должны легко находить необходимое. Для этого нужны фильтры, которые позволят через API получать нужное за минимальное количество запросов.
Советую выделить *роли*. Например, ваши DEV-, TEST- и PROD-среды. Или mgmnt-, data- и voice. Для сети может быть назначена только одна роль. Можно разделить на Sites или Tenants. Sites — это больше про географию, Tenants — про владение/ответственность за ресурсы.
Будет полезно продумать логическую вложенность для поиска. Например, мне надо найти mgmnt-адрес внутри сетей DC. Здесь логика бывает разная, можно как угодно скрещивать для поиска роли tenants, sites и tags. Теги (метки) удобны для сортировок агрегации, это межмодельная сущность: один тег может быть и на адресах, и на устройствах. Теги в NetBox цветные и красивые, на одной сущности их может быть сколько угодно, нет никаких ограничений.
Tenants — это сущность, разделяющая сами ресурсы и владение ими. Удобно для провайдеров услуг клиентам, но мы это не используем. Мы глобально выделяем большие роли DEV, TEST и PROD, а далее делим тегами как нам удобно. Для поиска и сортировок теги группируются как угодно: можно искать как в рамках модели, так и делать выборку по NetBox в целом.
В будущем мы раскидаем адреса и по sites/locations, чтобы получить еще больше возможностей для создания фильтров.
### Резервирование IP
Отдельно расскажу об этой возможности. При сервисном подходе клиент приходит к нам за IP-адресом и на стороннем портале заполняет свои пожелания. Затем сервис через API NetBox может прийти и взять для клиента IP-адрес. После того как клиент сдает ресурсы (например, VM), сервис так же через API освобождает адрес. Таким образом, время сетевых инженеров или архитекторов освобождается от части многочисленных рутинных задач.
Удобно использовать автообнаружение в заданных сетях. Так, после добавления сети через некоторое время в рамках сайта, к которому эта сеть привязана, появились наши устройства. Через указанные адреса можно получить доступ на устройство из NetBox через Napalm, собирать прямо в NetBox таким образом соседей и смотреть конфигурации железок.
### Что не так с phpIPAM
Для нас главная проблема phpIPAM в том, что это PHP, с которым копаться особого желания нет ни у кого. API, на мой взгляд, очень странный и непоследовательный, приходится писать много проверок, если надо что-то поискать. Его возможности сильно уступают NetBox в гибкости и многообразии endpoints и фильтров. Документация тоже оставляет желать лучшего.
NetBox же основан на привычном всем Python и дает полную свободу. Есть множество уже написанных для него плагинов, а если чего-либо не хватает, то всегда можно взять и написать свой. С версии 3.2 дружелюбность для писателей плагинов сильно возросла. Функциональность NetBox постоянно расширяется. На любые вопросы можно найти ответы в [Slack](https://netdev.chat/).
Но, конечно, не стоит переходить на NetBox просто для галочки. В нашем случае NetBox начали использовать в первую очередь как DCIM, и уже когда прижился, появилось желание вместо двух систем держать на поддержке одну.
### Переезд из phpIPAM в NetBox: планирование
Для начала нелишним будет оценить масштабы беспорядка в системе, из которой мы переезжаем. Следует узнать, не нужно ли перед переездом поработать с организацией текущей системы. Вполне возможно, что в ней уже что-то устарело, и по возможности стоит заранее прибраться. Затем надо решить, что и как мы будем переносить, определить сущности и составить план. Важно также определить, как будем переходить — разом или с учетом синхронизации по времени (хорошо если не в обе стороны).
Чтобы определить, что конкретно надо перенести из phpIPAM, стоит посмотреть по логам, кто им пользуется, пообщаться с заинтересованными сторонами и сформировать список требований к новой системе.
Если можно перейти сразу, то подойдет одноразовый скрипт без большого количества проверок и без логов. Если переносить под присмотром с ручной проверкой данных по обе стороны, такое решение можно реализовать за день. Мы переносили данные в таком формате; если все заинтересованные лица сразу готовы жить по-новому, можно сразу закрыть phpIPAM на редактирование. «Вошли и вышли, приключение на 20 минут».
Если требуется постепенный переход, когда пользователям надо оставить возможность работать и с NetBox, и с phpIPAM, придется писать полноценный ETL, хранить состояния, синхронизировать данные, писать много проверок и решать конфликты синхронизации. Это не наш размах, мы ограничились простым скриптом на один раз. Проверили вручную, что данные переехали корректно, прогнали некоторое количество интеграционных тестов и пошли пить кофе.
Когда в NetBox придут новые пользователи, для них нужно будет заводить группы и ограничивать права только на секцию IPAM в NetBox. Наверно, неплохо будет провести обучение по новой системе. Если с phpIPAM были какие-то интеграции, то коллегам надо будет дать время их переписать и помочь с освоением API NetBox. Он намного лучше, чем API phpIPAM, поэтому проблем быть не должно.
### Переезд из phpIPAM в NetBox: реализация
Расскажу, как проходила миграция у нас. Пообщавшись с коллегами и внутри группы, мы решили, что переносить будем сети, IP-адреса и VLAN с имеющимися названиями и описаниями там, где они будут, а также информацию о шлюзах и DNS. Для этих данных мы создали кастомные поля в рамках модели префикса.
Логически в phpIPAM у нас было деление на секции. В NetBox оно реализовано через роли для больших сущностей — DEV, TEST, CERT, PROD. Поскольку роль может быть только одна, для дальнейшего разделения будем использовать теги. Они удобны для сортировок, ими можно связывать разные модели для группировки. Можно было бы для этих целей использовать tenants и sites, но это менее удобно и не совсем корректно.
С версии 3.0 в NetBox появились ip-range, но мы их не стали использовать. По сравнению со старыми способом получить адрес они не дают преимуществ, не очень понятен профит. К тому же мы не хотели потерять совместимость с обвесом, написанным под API более ранних версий.
Итак, после анализа мы определились с последовательностью действий при переезде:
1. Заполнить aggregate
2. Заполнить RIR
3. Заполнить role
4. Заполнить tag
5. Перенести сети и описания
6. Перенести адреса в сети
7. Перенести VLAN и описания
8. Связать сети и VLAN
9. Раскидать роли
10. Раскидать теги
11. Проверить целостность данных
12. Проверить интеграции с коллегами
На github есть [реп](https://github.com/Callum027/ipam-migrator) с большой сложной переноской всего и вся из phpIPAM в NetBox. Но судя по комментам, там что-то не работает. Вместо того чтобы дебажить, что там не так (скорее всего, из-за смены API), мы решили написать решение сами для переноса только того, что нам надо. Для взаимодействия с API как в NetBox, так и phpIPAM удобно использовать token. Для phpIPAM нам хватить прав только на чтение, а к NetBox нужен полный доступ.
Вот как выглядит сценарий, отвечающий за перенос сетей и адресов. Комментарии в коде:
```
from typing import List, Dict, Optional
from datetime import datetime
from collections import Counter
from json.decoder import JSONDecodeError
from progress.bar import IncrementalBar
import ipaddress
import requests
import backoff
# подгружаем переменные, адрес апи и токены
from credential import NETBOX_API_TOKEN, NETBOX_API, PHP_IPAM_API, PHP_IPAM_API_TOKEN
# хедеры для апи запросов
HEADERS_NETBOX = {
'Authorization': f'Token {NETBOX_API_TOKEN}',
'Content-Type': 'application/json',
'Accept': 'application/json',
}
HEADERS_PHPIPAM = {
'Content-Type': 'application/json',
'token': PHP_IPAM_API_TOKEN
}
# создаем счетчик с переменным
# количество адресов
# количество префиксов
counter = Counter(ipaddr=0, pref=0)
requests.packages.urllib3.disable_warnings()
# обрабатывает ошибки и пробует 5 раз
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def pref_post_nb(
pref: str,
descr: Optional[str],
default_gateway: Optional[str],
gateway_from_id: Optional[str],
dns_name: Optional[str],
dns_servers: Optional[str]
) -> str:
# добавляем префикс в NetBox
netbox_api_endpoint = '/ipam/prefixes/'
# если нет информации, приравниваем к пустой строке
if descr is None: descr = ''
if default_gateway is None: default_gateway = ''
if dns_name is None: dns_name = ''
if dns_servers is None: dns_servers = ''
# сравниваем шлюз, если одинаковые, оставляем один
# сущности не связанные в phpIPAM
# дефолтного может не быть шлюза
if default_gateway == gateway_from_id:
payload = {
'prefix': f'{pref}',
'description': f'{descr}',
'custom_fields':{
'default_gateway': f'{default_gateway}',
'dns_name': f'{dns_name}',
'dns_servers': f'{dns_servers}'
}
}
else:
# если шлюзы отличаются или нет дефолтного, заносим оба
payload = {
'prefix': f'{pref}',
'description': f'{descr}',
'custom_fields':{
'default_gateway': f'Default gateway: {default_gateway}, Gateway: {gateway_from_id}',
'dns_name': f'{dns_name}',
'dns_servers': f'{dns_servers}'
}
}
pref_post_resp = requests.post(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
).json()
return f'SEND: {payload}, RECIVE: {pref_post_resp}'
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def ipaddr_post_nb(ipaddr: str, descr: Optional[str], host: Optional[str]) -> str:
# добавляем адрес в NetBox
netbox_api_endpoint = '/ipam/ip-addresses/'
# если нет описания или имени хоста, приравниваем к пустой строке
if descr is None: descr = ''
if host is None: host = ''
payload = {
'address': f'{ipaddr}',
'description': f'{descr}, hostname: {host}'
}
ipaddr_post_resp = requests.post(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
).json()
return f'SEND: {payload}, RECIVE: {ipaddr_post_resp}'
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def sec_get_from_phpipam() -> List[Dict[str, Optional[str]]]:
# получаем секции из phpIPAM
php_ipam_api_endpoint = '/autoNB/sections/'
sections_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
return sections_phpipam_resp
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def pref_get_from_sec(sec_id: str) -> List[Dict[str, Optional[str]]]:
# получаем префиксы из секции
php_ipam_api_endpoint = f'/autoNB/sections/{int(sec_id)}/subnets/'
pref_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
return pref_phpipam_resp
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def ipaddr_get_from_pref(pref_id: str) -> Optional[List[Dict[str, Optional[str]]]]:
# получаем адреса из секции
php_ipam_api_endpoint = f'/autoNB/subnets/{int(pref_id)}/addresses/'
try:
ipaddr_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
return ipaddr_phpipam_resp
# если адресов нет в префиксе
except KeyError:
return None
def pref_checker(pref: str) -> bool:
# проверяем, что это префикс, а не адрес
try:
ipaddress.ip_network(pref)
return True
except ValueError:
return False
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def ipaddr_by_id(id: Optional[str]) -> str:
# получить адрес шлюза по его ID
# если нет данных, вернем пустую строку
if id is None: return ''
php_ipam_api_endpoint = f'/autoNB/addresses/{id}/'
ipaddr_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']['ip']
# возвращаем адрес
return ipaddr_phpipam_resp
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_aggregate_from_netbox() -> List[str]:
# получаем агрегаты из NetBox
aggregates = []
netbox_api_endpoint = '/ipam/aggregates/'
aggregates_get_resp = requests.get(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, verify=False
).json()['results']
for aggregate in aggregates_get_resp:
aggregates.append(aggregate['prefix'])
return aggregates
def main() -> None:
# собираем логику
# время старта
start_time = datetime.now()
# открываем файл, в который запишем лог для анализа, если что-то пошло не по плану
with open('data/transfer_prefixes_from_phpipam_to_netbox.txt', 'a') as f:
aggregates = get_aggregate_from_netbox()
sections_phpipam_resp = sec_get_from_phpipam()
# запускаем счетчик в консоль, отсчитывающий количество секций из phpIPAM
bar = IncrementalBar('section : ' + '\t', max=len(sections_phpipam_resp))
# проходимся по секциям
for sec in sections_phpipam_resp:
bar.next()
# собираем префиксы из секции
pref_phpipam_resp = pref_get_from_sec(sec['id'])
# проверяем, что в секции есть префиксы
if len(pref_phpipam_resp) != 0:
# проходимся по префиксам из секции
for pref in pref_phpipam_resp:
# проверяем по ключу, что сеть не пустое значение
# в phpIPAM бывают сети папки, нам такие не нужны
if pref['subnet'] is not None:
# склеиваем префикс с маской
pref_with_mask = f'{pref["subnet"]}/{pref["mask"]}'
# проверяем, что префикс не из агрегатов NetBox
# если из них, то его не надо добавлять как префикс
if pref_with_mask not in aggregates:
# проверяем, что это сеть, а не адрес
if pref_checker(pref_with_mask):
# получаем его шлюз по ID адреса, если нет, то None
gateway_from_id = ipaddr_by_id(pref.get('gatewayId'))
# добавляем префикс, вместе с его описанием, DNS и Gateway
added_pref = pref_post_nb(
pref_with_mask,
pref['description'],
pref['Default Gateway'],
gateway_from_id,
# конструкция для неплоских словарей,
# если такой информации в phpIPAM нет, то и поля такого
# с вложенным словарем не будет
# тогда первый get вернет пустой словарь второму get
pref.get('nameservers', {}).get('name'),
pref.get('nameservers', {}).get('namesrv1')
)
# увеличиваем счетчик
counter.update({'pref': 1})
# делаем запись в лог
f.write(f'{datetime.now()} {added_pref}\n')
# получаем все адреса из префикса в phpIPAM
ipaddr_phpipam_resp = ipaddr_get_from_pref(pref['id'])
# проверяем, что адреса есть в префиксе
if ipaddr_phpipam_resp is not None:
# проходимся по всем адресам в префиксе
for ipaddr in ipaddr_phpipam_resp:
# склеиваем адрес с маской
ipaddr_with_mask = f'{ipaddr["ip"]}/{pref["mask"]}'
# добавляем в NetBox адресс, описание и имя хоста
added_addr = ipaddr_post_nb(
ipaddr_with_mask,
ipaddr['description'],
ipaddr['hostname']
)
counter.update({'ipaddr': 1})
f.write(f'{datetime.now()}: {added_addr}\n')
else:
# если сеть оказалась адресом, добавляем как адрес
added_addr = ipaddr_post_nb(pref_with_mask, pref['description'], '')
counter.update({'ipaddr': 1})
f.write(f'{datetime.now()}: {added_addr} not a prefix\n')
bar.finish()
# завершаем и выкидываем в консоль немного статистики
print(f'{counter["ipaddr"]} ip addreses added')
print(f'{counter["pref"]} prefixes added')
print(f'Script took {datetime.now() - start_time} to run')
if __name__ == '__main__':
main()
```
Следующий сценарий отвечает за перенос VLAN.
```
from typing import List, Dict, Any, Optional, Union
from datetime import datetime
from collections import Counter
from json.decoder import JSONDecodeError
from progress.bar import IncrementalBar
import requests
import backoff
# подгружаем переменные, адрес апи и токены
from credential import NETBOX_API_TOKEN, NETBOX_API, PHP_IPAM_API, PHP_IPAM_API_TOKEN
# хедеры для апи запросов
HEADERS_NETBOX = {
'Authorization': f'Token {NETBOX_API_TOKEN}',
'Content-Type': 'application/json',
'Accept': 'application/json',
}
HEADERS_PHPIPAM = {
'Content-Type': 'application/json',
'token': PHP_IPAM_API_TOKEN
}
# создаем счетчик с переменным
# количество групп - в качестве групп берем L2 домены из IPAM как есть
# количество VLAN
# количество префиксов, добавленных к VLAN
counter = Counter(groups_to_nb=0, vlan=0, vlan_to_pref=0)
requests.packages.urllib3.disable_warnings()
# обрабатывает ошибки и пробует 5 раз
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_all_l2_domain_phpipam() -> List[Dict[str, Any]]:
# собираем l2 домены в словарь
l2_domains = []
php_ipam_api_endpoint = '/autoNB/l2domains/'
l2_domains_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
for l2_domain in l2_domains_phpipam_resp:
l2_domains.append({
'id': l2_domain['id'],
'name': l2_domain['name'],
'description': l2_domain['description'],
})
return l2_domains
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_l2_domain_by_id_phpipam(id:str) -> Dict[str, Any]:
# берем l2 домен по его ID
php_ipam_api_endpoint = f'/autoNB/l2domains/{id}/'
l2_domain_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
l2_domain_group = {
'id': l2_domain_phpipam_resp['id'],
'name': l2_domain_phpipam_resp['name'],
'description': l2_domain_phpipam_resp['description'],
}
return l2_domain_group
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_vlans_phpipam() -> List[Dict[str, Any]]:
# собираем VLAN и phpIPAM
vlans = []
php_ipam_api_endpoint = '/autoNB/vlan/'
vlans_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
for vlan in vlans_phpipam_resp:
vlans.append({
'idphp': vlan['vlanId'],
'name': vlan['name'],
'vid': vlan['number'],
'description': vlan['description'],
'l2_domain': vlan['domainId'],
})
return vlans
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_pref_for_vlans_phpipam(idphp) -> Union[List[str], bool]:
# собираем префиксы, связанные с VLAN, в список
ips = []
php_ipam_api_endpoint = f'/autoNB/vlan/{idphp}/subnets/'
try:
pref_from_vlan_phpipam_resp = requests.get(
PHP_IPAM_API + php_ipam_api_endpoint, headers=HEADERS_PHPIPAM, verify=False
).json()['data']
for ip in pref_from_vlan_phpipam_resp:
ips.append(f'{ip["subnet"]}/{ip["mask"]}')
return ips
except KeyError:
ips = False
return ips
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def post_group_nb(name: str, description: Optional[str]) -> str:
# добавляем l2 домены из phpIPAM как группы в NetBox
netbox_api_endpoint = '/ipam/vlan-groups/'
if description is None: description = ''
# имя, описание и slug без пробелов
payload = {
'name': name,
'description': description,
'slug': f'{name.replace(" ", "").lower()}',
}
group_post_resp = requests.post(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
).json()
return f'SEND: {payload}, RECIVE: {group_post_resp}'
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def post_vlan_on_group_nb(vid : int, name: str, description: Optional[str], group_id: int) -> str:
# добавляем VLAN в группы
netbox_api_endpoint = '/ipam/vlans/'
if description is None: description = ''
# потребуется ID группы
payload = {
'name': name,
'description': description,
'vid': vid,
'group': group_id,
}
pref_post_resp = requests.post(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
).json()
return f'SEND: {payload}, RECIVE: {pref_post_resp}'
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def patch_vlan_to_pref_nb(pref_id: int, vlan_id: int) -> str:
# связываем VLAN и префикс
netbox_api_endpoint = '/ipam/prefixes/'
# потребуются ID VLAN и префиксов
payload = [{
'id': pref_id,
'vlan': vlan_id,
}]
pref_patch_resp = requests.patch(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
).json()
return f'SEND: {payload}, RECIVE: {pref_patch_resp}'
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_vlan_id_from_nb(vlan: str, group_id: int) -> int:
# получаем ID VLAN из NetBox
netbox_api_endpoint = '/ipam/vlans/'
# фильтруем по номеру VLAN и ID его группы
params = {
'vid': vlan,
'group_id': group_id,
}
vlan_get_id_resp = requests.get(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, params=params, verify=False
).json()["results"][0]["id"]
return vlan_get_id_resp
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_pref_id_from_nb(prefix: str) -> int:
# получаем ID префикса
netbox_api_endpoint = '/ipam/prefixes/'
params = {
'prefix': prefix
}
pref_get_id_resp = requests.get(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, params=params, verify=False
).json()['results'][0]['id']
return pref_get_id_resp
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_group_id_from_nd() -> Dict[str, int]:
# получаем ID групп из NetBox,
# собираем в словарь имя и ID
# если нет групп, возвращаем пустой словарь
group_name_id = {}
netbox_api_endpoint = '/ipam/vlan-groups/'
groups_get_resp = requests.get(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, verify=False
).json()['results']
if groups_get_resp:
for group in groups_get_resp:
group_name_id[group['name']] = group['id']
return group_name_id
else: return group_name_id
def main():
# собираем логику
# время старта
start_time = datetime.now()
# открываем файл, в который запишем лог для анализа, если что-то пошло не по плану
with open('data/transfer_vlan_from_phpipam_to_netbox.txt', 'a') as f:
# получаем VLANS
vlans = get_vlans_phpipam()
# запускаем счетчик в консоль, отсчитывающий количество VLAN
bar = IncrementalBar('Vlans : ' + '\t', max=len(vlans))
# получаем домены
l2_domains = get_all_l2_domain_phpipam()
# проверяем, какие группы уже есть в NetBox
group_name_id_pre = get_group_id_from_nd()
for l2_domain in l2_domains:
# проверяем что нашей там нет, чтобы не создать дубликат
if not group_name_id_pre.get(l2_domain['name']):
# пробегаемся по доменам, создавая группы в NetBox
post_groups_nb_results = post_group_nb(l2_domain['name'], l2_domain['description'])
# записываем результат в лог с текущей датой
f.write(f'{datetime.now()} {post_groups_nb_results}\n')
# увеличиваем счетчик на 1
counter.update({'groups_to_nb': 1})
# собираем ID групп из NetBox
group_name_id = get_group_id_from_nd()
# проходимся по всем VLAN
for vlan in vlans:
# увеличиваем консольный счетчик на 1
bar.next()
# собираем в словарь всю информацию по VLAN, которая понадобится
# выкладываем информацию о группе и о префиксах
vlan['group'] = get_l2_domain_by_id_phpipam(vlan['l2_domain'])
vlan['prefixes'] = get_pref_for_vlans_phpipam(vlan['idphp'])
# берем ID группы этого VLAN из словаря
group_id = group_name_id[vlan['group']['name']]
# добавляем VLAN в NetBox
post_vlan_result = post_vlan_on_group_nb(
vlan['vid'],
vlan['name'],
vlan['description'],
group_id,
)
f.write(f'{datetime.now()} {post_vlan_result}\n')
counter.update({'vlan': 1})
# если у VLAN есть префиксы, связываем их
if vlan['prefixes']:
# убеждаемся, что VLAN ID есть в группе NetBox
try:
vlan_id_nb = get_vlan_id_from_nb(vlan['vid'], group_id)
for prefix in vlan['prefixes']:
# убеждаемся, что префикс есть в NetBox
try:
pref_id_nb = get_pref_id_from_nb(prefix)
except IndexError:
# если префикса нет, сохраняем в лог
f.write(f'Pref not exist {datetime.now()} {prefix}\n')
continue
# связываем VLAN и префикс
patch_vlan_to_pref_result = patch_vlan_to_pref_nb(pref_id_nb, vlan_id_nb)
f.write(f'{datetime.now()} {patch_vlan_to_pref_result}\n')
counter.update({'vlan_to_pref': 1})
except IndexError:
# если есть совпадения имен, такого VLAN ID не будет в группе
f.write(f'Duplicate vlan name {datetime.now()} {vlan}\n')
continue
bar.finish()
# немного статистики в консоль
print(f'{counter["groups_to_nb"]} groups added to NetBox')
print(f'{counter["vlan"]} vlanes added to NetBox')
print(f'{counter["vlan_to_pref"]} prefixes matched with vlans')
print(f'Script took {datetime.now() - start_time} to run')
if __name__ == '__main__':
main()
```
Запустили первый, запустили второй, проверили — можно и по кофе с булочкой :)
Если что-то не получилось или данные надо переделать, NetBox не даст легко удалить все адреса и VLAN, пока не удалены все привязанные к ним префиксы. Поэтому последовательность такая:
1. Удалить все префиксы
2. Удалить все VLAN
3. Удалить все адреса
Если надо сделать это быстро, то можно сходить в базу данных и почистить там таблицы в той же последовательности. Мне спокойнее делать всё через API, чтобы перестраховаться от того, что я вдруг что-то не учел и в базе, из-за чего могут пойти ошибки.
Вот простенький сценарий для удаления всего из секции IPAM NetBox:
```
from typing import List, Dict, Optional
from datetime import datetime
from json.decoder import JSONDecodeError
import requests
import backoff
from credential import NETBOX_API_TOKEN, NETBOX_API
requests.packages.urllib3.disable_warnings()
HEADERS_NETBOX = {
'Authorization': f'Token {NETBOX_API_TOKEN}',
'Content-Type': 'application/json',
'Accept': 'application/json',
}
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_vlans(limit_per_page: int = 50) -> Optional[List[Dict[str, int]]]:
# собираем ID VLAN пачками по 50
vlan_ids = []
netbox_api_endpoint = '/ipam/vlans/'
params = {
'limit': f'{limit_per_page}'
}
vlans_get_resp = requests.get(
NETBOX_API + netbox_api_endpoint, params=params, headers=HEADERS_NETBOX, verify=False
).json()['results']
# проверяем, что еще есть VLAN
if vlans_get_resp:
for vlan in vlans_get_resp:
vlan_ids.append({'id': vlan['id']})
return vlan_ids
# если VLAN кончились, возвращаем None
else: return
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def delete_vlans(vlans: List[Dict[str, int]]):
# удаляем VLAN пачкой по 50
netbox_api_endpoint = '/ipam/vlans/'
# отправляем список словарей с ID
payload = vlans
vlans_delete_resp = requests.delete(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
)
# выводим в консоль статус код запроса
print(vlans_delete_resp.status_code)
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_prefixes(limit_per_page: int = 50) -> Optional[List[Dict[str, int]]]:
# собираем ID префиксов пачками по 50
prefixes_ids = []
netbox_api_endpoint = '/ipam/prefixes/'
params = {
'limit': f'{limit_per_page}'
}
prefixes_get_resp = requests.get(
NETBOX_API + netbox_api_endpoint, params=params, headers=HEADERS_NETBOX, verify=False
).json()['results']
# проверяем, что еще есть префиксы
if prefixes_get_resp:
for prefix in prefixes_get_resp:
prefixes_ids.append({'id': prefix['id']})
return prefixes_ids
# если префиксы кончились, возвращаем None
else: return
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def delete_prefix(prefixes: List[Dict[str, int]]):
# удаляем префиксы пачками по 50
netbox_api_endpoint = '/ipam/prefixes/'
# отправляем список словарей, в котором ID
payload = prefixes
prefixes_delete_resp = requests.delete(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
)
# выводим в консоль статус-код запроса
print(prefixes_delete_resp.status_code)
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def get_ipaddresses(limit_per_page: int = 50) -> Optional[List[Dict[str, int]]]:
# собираем ID адресов пачками по 50
ipaddresses_ids = []
netbox_api_endpoint = '/ipam/ip-addresses/'
params = {
'limit': f'{limit_per_page}'
}
ipaddresses_get_resp = requests.get(
NETBOX_API + netbox_api_endpoint, params=params, headers=HEADERS_NETBOX, verify=False
).json()['results']
# проверяем, что еще есть адреса
if ipaddresses_get_resp:
for ipaddres in ipaddresses_get_resp:
ipaddresses_ids.append({'id': ipaddres['id']})
return ipaddresses_ids
# если адреса кончились, возвращаем None
else: return
@backoff.on_exception(
backoff.expo,
(requests.exceptions.RequestException, JSONDecodeError),
max_tries=5
)
def delete_ipaddr(ipaddresses: List[Dict[str, int]]):
# удаляем адреса пачками по 50
netbox_api_endpoint = '/ipam/ip-addresses/'
# отправляем список словарей, в которых ID
payload = ipaddresses
ipaddresses_delete_resp = requests.delete(
NETBOX_API + netbox_api_endpoint, headers=HEADERS_NETBOX, json=payload, verify=False
)
# выводим в консоль статус код запроса
print(ipaddresses_delete_resp.status_code)
def main():
# собираем логику
# стартуем
start_time = datetime.now()
# крутимся, пока не вернется None
while get_prefixes():
# получаем пачка ID 50 штук
prefixes_ids = get_prefixes()
# удаляем пачку
delete_prefix(prefixes_ids)
while get_vlans():
vlan_ids = get_vlans()
delete_vlans(vlan_ids)
while get_ipaddresses():
ipaddresses_ids = get_ipaddresses()
delete_ipaddr(ipaddresses_ids)
print(f'Script took {datetime.now() - start_time} to run')
if __name__ == '__main__':
main()
Содержимое файла credential.py с переменным для сценариев:
NETBOX_API_TOKEN = 'ТОКЕН'
NETBOX_API = 'https://netbox/api/'
PHP_IPAM_API = 'https://ipam/api/'
PHP_IPAM_API_TOKEN = 'ТОКЕН'
```
Лучше сначала разработать и проверить всё в тестовом NetBox и параллельно готовить всех пользователей к переходу и переходному этапу. Когда придет день официального перехода, делаем перенос на PROD NetBox, закрываем phpIPAM на редактирование, чтобы базы не разъезжались, и наблюдаем. Помогаем пользователям перейти на новую систему, решаем возникшие проблемы. PhpIPAM не тушим, чтобы у пользователей была возможность сравнить данные (вдруг мы что-то забыли). При этом держим наготове включение phpIPAM, если у кого-нибудь вдруг слетит критичная интеграция, вследствие чего он не получит свой адрес.
Много чего в моих примерах можно переписать под свои задачи. Например, для сборки JSON из phpIPAM можно прикрутить Mongo и хранить там данные, не пересобирая всё на лету. Это позволит не узнавать постоянно ID у NetBox. Если нужно будет делать ETL, вам пригодятся webhook из NetBox. Также желательно добавить тесты, и сравнить базы, чтобы их совпадение составило 100%, с выводом разницы, если она есть.
Все примеры взяты из [песочницы NetBox](https://demo.netbox.dev/). В следующей статье я расскажу, как мы освоили преимущества custom fields со ссылкой на другую модель, а также conditional webhooks на примере интеграции NetBox и Cisco ACI. | https://habr.com/ru/post/678124/ | null | ru | null |
# Уроки компьютерного зрения на Python + OpenCV с самых азов. Часть 8
[**Оглавление**](https://habr.com/ru/post/688316/).
На [прошлом уроке](https://habr.com/ru/post/676838/) мы углубились в изучение контуров. В частности, научились работать со структурой, которую возвращает функция выделения контуров, научились аппроксимировать и обходить контур, научились программировать кое-какие геометрические операции, чтобы создать инвариантное описание объекта. Напомню, как это мы сделали: нашли контур объекта, аппроксимировали его, обошли этот контур, вычислили косинусы углов между гранями аппроксимированного контура.
Сегодня продолжим тему [прошлого урока](https://habr.com/ru/post/676838/). Вычислим инвариантный вектор новым методом: через отношения длин сторон. Мы начнем обход так же с самой удаленной от центра точки, только будем брать стороны, а не углы межу сторонами. И первая сторона это та, что прилегает к первой точке. То есть она соединяет первую точку и следующую за ней по часовой стрелке. И все эти длины сторон мы разделим на самую длинную сторону. Хотя нет, сделам лучше. Сделаем минимакс нормализацию: вычтем из длины стороны минимум и разделим на разницу между минимумом и максимумом. У нас будет вектор чисел от 0 до 1.
И так, займемся кодингом. Сначала напишем цикл, создающий исходный масcив:
```
lengths=[]
for i in range(size-1):
lengths.append(get_length(polar_coordinates[i],polar_coordinates[i+1]))
lengths.append(get_length(polar_coordinates[size-1],polar_coordinates[0]))
print(get_normalize_normalize(lengths))
```
Функция вычисления длины стороны (она просто извекает из структуры, где у нас все храниться, координаты и считает эвклидово расстояние):
```
#Эвклидово расстояние между двумя элементами
def get_length(item1, item2):
_, point1 = item1
_, point2 = item2
x1, y1 = point1
x2, y2 = point2
dx=x1-x2
dy=y1-y2
r=math.sqrt(dx*dx+dy*dy)
return r
```
Ну и нормализация, конвертим полученный список в numpy массив и делаем минимакс нормализацию:
```
def get_normalized_vector(list):
arr=np.array(list)
return (arr-arr.min())/(arr.max()-arr.min())
```
Поехали смотреть, что получилось.
Первый пример:
Вектор: [0.11331868 1. 0. 0.02997931 0.96756226 0.1022278 ]
Второй пример:
Вектор: [0.16953268 0.9532099 0. 0.01245409 1. 0.10313678]
Как видим, векторы действительно оказались близкие. Причем, в отличие от прошлого варианта, у нас остаются стабильными все элементы вектора.
Вообще, по-хорошему, конечно надо бы провести исследование: проанализировать множество изображений, сравнить, насколько расходятся векторы инвариантных описаний при том или ином методе расчета. Да и программа нуждается в рефакторинге. Но это уже выходит за рамки уроков. Поэтому я привожу полный код примеров как есть, и мы двигаемся дальше:
```
import cv2
import numpy as np
import math
import os
img = cv2.imread("Samples/1.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
thresh = 100
def custom_sort(countour):
return -countour.shape[0]
def polar_sort(item):
return item[0][0]
def get_normalized_vector(list):
arr=np.array(list)
return (arr-arr.min())/(arr.max()-arr.min())
#Эвклидово расстояние между двумя элементами
def get_length(item1, item2):
_, point1 = item1
_, point2 = item2
x1, y1 = point1
x2, y2 = point2
dx=x1-x2
dy=y1-y2
r=math.sqrt(dx*dx+dy*dy)
return r
def get_cos_edges(edges):
dx1, dy1, dx2, dy2=edges
r1 = math.sqrt(dx1 * dx1 + dy1 * dy1)
r2 = math.sqrt(dx2 * dx2 + dy2 * dy2)
return (dx1*dx2+dy1*dy2)/r1/r2
def get_polar_coordinates(x0,y0,x,y,xc,yc):
#Первая координата в полярных координатах - радиус
dx=xc-x
dy=yc-y
r=math.sqrt(dx*dx+dy*dy)
#Вторая координата в полярных координатах - узел, вычислим относительно начальной точки
dx0=xc-x0
dy0=yc-y0
r0 = math.sqrt(dx0 * dx0 + dy0 * dy0)
scal_mul=dx0*dx+dy0*dy
cos_angle=scal_mul/r/r0
sgn=dx0*dy-dx*dy0 #опредедляем, в какую сторону повернут вектор
if cos_angle>1:
if cos_angle>1.0001:
raise Exception("Что-то пошло не так")
cos_angle=1
angle=math.acos(cos_angle)
if sgn<0:
angle=2*math.pi-angle
return angle,r
def get_coords(item1, item2, item3):
_, point1 = item1
_, point2 = item2
_, point3 = item3
x1, y1 = point1
x2, y2 = point2
x3, y3 = point3
dx1=x1-x2
dy1=y1-y2
dx2=x3-x2
dy2=y3-y2
return dx1,dy1,dx2,dy2
#get threshold image
ret,thresh_img = cv2.threshold(gray, thresh, 255, cv2.THRESH_BINARY)
# find contours without approx
contours,_ = cv2.findContours(thresh_img,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
contours=list(contours)
contours.sort(key=custom_sort)
sel_countour=contours[1]
# calc arclentgh
arclen = cv2.arcLength(sel_countour, True)
# do approx
eps = 0.01
epsilon = arclen * eps
approx = cv2.approxPolyDP(sel_countour, epsilon, True)
sum_x=0.0
sum_y=0.0
for point in approx:
x = float(point[0][0])
y = float(point[0][1])
sum_x+=x
sum_y+=y
xc=sum_x/float(len((approx)))
yc=sum_y/float(len((approx)))
max=0
beg_point=-1
for i in range(0,len(approx)):
point=approx[i]
x = float(point[0][0])
y = float(point[0][1])
dx=x-xc
dy=y-yc
r=math.sqrt(dx*dx+dy*dy)
if r>max:
max=r
beg_point=i
polar_coordinates=[]
x0=approx[beg_point][0][0]
y0=approx[beg_point][0][1]
for point in approx:
x = int(point[0][0])
y = int(point[0][1])
angle,r=get_polar_coordinates(x0,y0,x,y,xc,yc)
polar_coordinates.append(((angle,r),(x,y)))
polar_coordinates.sort(key=polar_sort)
img_contours = np.uint8(np.zeros((img.shape[0],img.shape[1])))
size=len(polar_coordinates)
for i in range(1,size):
_ , point1=polar_coordinates[i-1]
_, point2 = polar_coordinates[i]
x1,y1=point1
x2,y2=point2
cv2.line(img_contours, (x1, y1), (x2, y2), 255, thickness=i)
_ , point1=polar_coordinates[size-1]
_, point2 = polar_coordinates[0]
x1,y1=point1
x2,y2=point2
cv2.line(img_contours, (x1, y1), (x2, y2), 255, thickness=size)
cv2.circle(img_contours, (int(xc), int(yc)), 7, (255,255,255), 2)
coses=[]
coses.append(get_cos_edges(get_coords(polar_coordinates[size-1],polar_coordinates[0],polar_coordinates[1])))
for i in range(1,size-1):
coses.append(get_cos_edges(get_coords(polar_coordinates[i-1], polar_coordinates[i],polar_coordinates[i+1])))
coses.append(get_cos_edges(get_coords(polar_coordinates[size-2], polar_coordinates[size-1],polar_coordinates[0])))
print(coses)
lengths=[]
for i in range(size-1):
lengths.append(get_length(polar_coordinates[i],polar_coordinates[i+1]))
lengths.append(get_length(polar_coordinates[size-1],polar_coordinates[0]))
print(get_normalized_vector(lengths))
point=approx[beg_point]
x = float(point[0][0])
y = float(point[0][1])
cv2.circle(img_contours, (int(x), int(y)), 7, (255,255,255), 2)
cv2.imshow('origin', img) # выводим итоговое изображение в окно
cv2.imshow('res', img_contours) # выводим итоговое изображение в окно
cv2.waitKey()
cv2.destroyAllWindows()
```
Наш следующий шаг в освоении OpenCV – это поиск предмета на изображении. Искать мы будет все ту же ручку, но теперь на изображении у нас будут другие предметы:
Здесь мы точно так же выделим контуры на изображении, а потом каждый из контуров будем проверять на соответствии заданному шаблону – шесть граней и вектор инвариантного описания близок к исходному. Насколько близок? Это определим эмпирическим путем, подбирая порог.
И так, вот программа:
```
import cv2
import numpy as np
import math
template_vector=np.array([0.16953268, 0.9532099, 0, 0.01245409, 1, 0.10313678])
distance_thresh=0.1
img = cv2.imread("Samples/objects.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
thresh = 100
def polar_sort(item):
return item[0][0]
def get_normalized_vector(list):
arr=np.array(list)
return (arr-arr.min())/(arr.max()-arr.min())
#Эвклидово расстояние между двумя элементами
def get_length(item1, item2):
_, point1 = item1
_, point2 = item2
x1, y1 = point1
x2, y2 = point2
dx=x1-x2
dy=y1-y2
r=math.sqrt(dx*dx+dy*dy)
return r
def get_polar_coordinates(x0,y0,x,y,xc,yc):
#Первая координата в полярных координатах - радиус
dx=xc-x
dy=yc-y
r=math.sqrt(dx*dx+dy*dy)
#Вторая координата в полярных координатах - узел, вычислим относительно начальной точки
dx0=xc-x0
dy0=yc-y0
r0 = math.sqrt(dx0 * dx0 + dy0 * dy0)
scal_mul=dx0*dx+dy0*dy
cos_angle=scal_mul/r/r0
sgn=dx0*dy-dx*dy0 #опредедляем, в какую сторону повернут вектор
if cos_angle>1:
if cos_angle>1.0001:
raise Exception("Что-то пошло не так")
cos_angle=1
angle=math.acos(cos_angle)
if sgn<0:
angle=2*math.pi-angle
return angle,r
#get threshold image
ret,thresh_img = cv2.threshold(gray, thresh, 255, cv2.THRESH_BINARY)
# find contours without approx
contours,_ = cv2.findContours(thresh_img,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
for sel_countour in contours:
# calc arclentgh
arclen = cv2.arcLength(sel_countour, True)
# do approx
eps = 0.01
epsilon = arclen * eps
approx = cv2.approxPolyDP(sel_countour, epsilon, True)
#Обрабатываем только контуры длиной 6 углов
if len(approx)==6:
# вычислим центр тяжести контура
sum_x = 0.0
sum_y = 0.0
for point in approx:
x = float(point[0][0])
y = float(point[0][1])
sum_x += x
sum_y += y
xc = sum_x / float(len((approx)))
yc = sum_y / float(len((approx)))
#найдем начальную точку
max = 0
beg_point = -1
for i in range(0, len(approx)):
point = approx[i]
x = float(point[0][0])
y = float(point[0][1])
dx = x - xc
dy = y - yc
r = math.sqrt(dx * dx + dy * dy)
if r > max:
max = r
beg_point = i
#Вычислми полярные координаты
polar_coordinates=[]
x0=approx[beg_point][0][0]
y0=approx[beg_point][0][1]
for point in approx:
x = int(point[0][0])
y = int(point[0][1])
angle, r = get_polar_coordinates(x0, y0, x, y, xc, yc)
polar_coordinates.append(((angle, r), (x, y)))
#Создадим вектор описание
polar_coordinates.sort(key=polar_sort)
size = len(polar_coordinates)
lengths = []
for i in range(size - 1):
lengths.append(get_length(polar_coordinates[i], polar_coordinates[i + 1]))
lengths.append(get_length(polar_coordinates[size - 1], polar_coordinates[0]))
descr=get_normalized_vector(lengths)
#Вычислим эвклидово расстояние
square = np.square(descr - template_vector)
sum_square = np.sum(square)
distance = np.sqrt(sum_square)
if distance
```
Порог подобран 0.1, шаблон – вектор ко второй картинке, где искомый объект повернут в другую сторону, чем тот, что на картинке:
```
template_vector=np.array([0.16953268, 0.9532099, 0, 0.01245409, 1, 0.10313678])
distance_thresh=0.1
```
И вот что у нас получилось:
Найден всего один объект. Если порог увеличить до 0.4, то будет найдет и второй объект, но еще несколько «левых» объектов:
Избавить мы можем от них, просто введя критерий размера (не имеет смысл рассматривать слишком малые объекты):
```
…
for sel_countour in contours:
# calc arclentgh
arclen = cv2.arcLength(sel_countour, True)
if arclen<20:
continue
…
```
И вот что мы получим теперь:
Но кто сказал, что надо вообще аппроксимировать контур и считать углы? Мы можем просто обойти контур по кругу, который разделим на определенное кол-во секторов:
```
count=100
full_angle=2*math.pi
i=1
end_angle = float(i) * full_angle / float(count)
summ=0.0
count_angles=0.0
signature=[]
for item_coord in polar_coord:
angle,r=item_coord
if angle>end_angle:
signature.append((angle,summ/count_angles))
i+=1
end_angle = float(i) * full_angle / float(count)
summ=0
count_angles=0
summ+=r
count_angles+=1
signature.append((angle,summ/count_angles))
print(signature)
```
Для того, чтобы проверить правильность формирования сигнатуры, переведем ее опять в декартовы координаты и отобразим. Функция перевода полярных координат в декартовы:
```
def polar_to_decart(angle,r):
x=math.sin(angle)*r
y=math.cos(angle)*r
return x,y
```
И вот таким образом мы отобразим сигнатуру:
```
img_contours = np.zeros((img.shape[0],img.shape[1],3), np.uint8) # np.uint8(np.zeros((img.shape[0],img.shape[1])))
cv2.drawContours(img_contours, [sel_countour], -1, (255,0,0), 1)
for i in range(1,len(signature)):
angle1,r1=signature[i-1]
angle2,r2=signature[i]
x1, y1=polar_to_decart(angle1,r1)
x2, y2 = polar_to_decart(angle2, r2)
cv2.line(img_contours, (int(x1+xc), int(y1+yc)), (int(x2+xc), int(y2+yc)), (0,0,255), thickness=1)
angle1,r1=signature[len(signature)-1]
angle2,r2=signature[0]
x1, y1=polar_to_decart(angle1,r1)
x2, y2 = polar_to_decart(angle2, r2)
cv2.line(img_contours, (int(x1+xc), int(y1+yc)), (int(x2+xc), int(y2+yc)), (0,0,255), thickness=1)
```
Да, я специально не стал делать поправку на угол, чтобы совмещать контуры, пусть красный контур (сигнатура) будет повернут, чтобы было лучше видно:
Можно отобразить эту сигнатуру на графике:
```
x=[]
y=[]
for item in signature:
angle,r=item
x.append(angle)
y.append(r)
plt.plot(x,y)
plt.show()
```
Заметим, что неважно, какой угол поворота, графики будут выглядеть одинаково:
Ну, или почти одинаково:
Сравнить мы его сможет так же, как и вектора. Тем более, что теперь у нас контур приведен к единоразмерной сигнатуре.
Попробуем другой предмет:
Как видим, в случае круглого предмета получился шум вокруг определенного уровня - радиуса этого круга. В идеале должна, конечно, получиться прямая, но ничего в этом мире нет идеального.
Еще один предмет:
Еще сигнатуру можно нормировать, тогда мы получим инвариантный к размеру вектор. В прошлый раз мы использовали минимакс, но есть и другие способы, например, можно разделить на радиус или делить разницу между текущим и средним значением на среднеквадратическое отклонение. Но обсуждение способов нормирования уже выходит за рамки статьи.
В заключении полный текст программы.
Файл SignLib.py:
```
import math
def custom_sort(countour):
return -countour.shape[0]
def get_center(countour):
# вычислим центр тяжести контура
sum_x = 0.0
sum_y = 0.0
for point in countour:
x = float(point[0][0])
y = float(point[0][1])
sum_x += x
sum_y += y
xc = sum_x / float(len((countour)))
yc = sum_y / float(len((countour)))
return xc,yc
def get_beg_point(countour,xc,yc):
max = 0
beg_point = -1
for i in range(0, len(countour)):
point = countour[i]
x = float(point[0][0])
y = float(point[0][1])
dx = x - xc
dy = y - yc
r = math.sqrt(dx * dx + dy * dy)
if r > max:
max = r
beg_point = i
return beg_point
def get_polar_coordinates(x0,y0,x,y,xc,yc):
#Первая координата в полярных координатах - радиус
dx=xc-x
dy=yc-y
r=math.sqrt(dx*dx+dy*dy)
#Вторая координата в полярных координатах - узел, вычислим относительно начальной точки
dx0=xc-x0
dy0=yc-y0
r0 = math.sqrt(dx0 * dx0 + dy0 * dy0)
scal_mul=dx0*dx+dy0*dy
cos_angle=scal_mul/r/r0
sgn=dx0*dy-dx*dy0 #опредедляем, в какую сторону повернут вектор
if cos_angle>1:
if cos_angle>1.0001:
raise Exception("Что-то пошло не так")
cos_angle=1
angle=math.acos(cos_angle)
if sgn<0:
angle=2*math.pi-angle
return angle,r
def polar_to_decart(angle,r):
x=math.sin(angle)*r
y=math.cos(angle)*r
return x,y
def polar_sort(item):
return item[0]
def get_polar_coordinates_list(countour,xc,yc,beg_point):
polar_coordinates = []
x0 = countour[beg_point][0][0]
y0 = countour[beg_point][0][1]
for point in countour:
x = int(point[0][0])
y = int(point[0][1])
angle, r = get_polar_coordinates(x0, y0, x, y, xc, yc)
polar_coordinates.append((angle, r))
# Создадим вектор описание
polar_coordinates.sort(key=polar_sort)
return polar_coordinates
```
Основной файл программы:
```
import math
import matplotlib.pyplot as plt
import cv2
import numpy as np
from SignLib import custom_sort, get_center, get_beg_point, get_polar_coordinates_list, polar_to_decart
img = cv2.imread("Samples/battery.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
thresh = 100
#get threshold image
ret,thresh_img = cv2.threshold(gray, thresh, 255, cv2.THRESH_BINARY)
# find contours without approx
contours,_ = cv2.findContours(thresh_img,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
contours=list(contours)
contours.sort(key=custom_sort)
sel_countour=contours[1]
xc,yc=get_center(sel_countour)
beg_point=get_beg_point(sel_countour,xc,yc)
polar_coord=get_polar_coordinates_list(sel_countour,xc,yc,beg_point)
count=100
full_angle=2*math.pi
i=1
end_angle = float(i) * full_angle / float(count)
summ=0.0
count_angles=0.0
signature=[]
for item_coord in polar_coord:
angle,r=item_coord
if angle>end_angle:
signature.append((angle,summ/count_angles))
i+=1
end_angle = float(i) * full_angle / float(count)
summ=0
count_angles=0
summ+=r
count_angles+=1
signature.append((angle,summ/count_angles))
print(signature)
img_contours = np.zeros((img.shape[0],img.shape[1],3), np.uint8) # np.uint8(np.zeros((img.shape[0],img.shape[1])))
cv2.drawContours(img_contours, [sel_countour], -1, (255,0,0), 1)
for i in range(1,len(signature)):
angle1,r1=signature[i-1]
angle2,r2=signature[i]
x1, y1=polar_to_decart(angle1,r1)
x2, y2 = polar_to_decart(angle2, r2)
cv2.line(img_contours, (int(x1+xc), int(y1+yc)), (int(x2+xc), int(y2+yc)), (0,0,255), thickness=1)
angle1,r1=signature[len(signature)-1]
angle2,r2=signature[0]
x1, y1=polar_to_decart(angle1,r1)
x2, y2 = polar_to_decart(angle2, r2)
cv2.line(img_contours, (int(x1+xc), int(y1+yc)), (int(x2+xc), int(y2+yc)), (0,0,255), thickness=1)
cv2.imshow('origin', img) # выводим итоговое изображение в окно
cv2.imshow('res', img_contours) # выводим итоговое изображение в окно
x=[]
y=[]
for item in signature:
angle,r=item
x.append(angle)
y.append(r)
plt.plot(x,y)
plt.show()
cv2.waitKey()
cv2.destroyAllWindows()
``` | https://habr.com/ru/post/687864/ | null | ru | null |
# +(AppStore *) Timera: архитектура приложения и особенности разработки
Настала пора поведать общественности о нашем приложении timera. C сегодняшнего дня его можно скачать в appstore.
Об архитектуре timera расскажет [heximal (Павел)](http://habrahabr.ru/users/heximal/), наш ios разработчик, у него сейчас read only, поэтому его пост публикую я.
— > В этом посте я напишу о моем скромном участии в интересном и перспективном проекте с весьма оригинальным названием Timera (от слов time и era). По удачному стечению обстоятельств я пребывал в активной фазе поисков новых горизонтов развития в тот самый момент, когда руководство стартапа искало кандидата на вакансию iOS-разработчика. Суть проекта довольно проста – ее визуальное представление и описание архитектуры можно видеть на главной иллюстрации к посту, под катом.
Пользователю представляется инструмент для создания временнОго туннеля, путем совмещения фотографии из прошлого с фотографией, сделанной камерой смартфона. Идея мне очень понравилась, и я незамедлительно начал интегрироваться в процесс разработки, в ходе которого пришлось столкнуться и преодолеть немало сложных и интересных задач.
Прежде всего, хотелось бы пару слов сказать о глобальной архитектуре. Центральным звеном является сервер, выполняющий функции back-end, front-end, data storage, web-api. Подробно описывать серверную начинку не стану, поскольку никакого касательства к ней не имею. Cкажу лишь, что production-версия работает на облачном хостинге от Microsoft, а для реализации server-side использовался классический на сегодняшний момент стэк: IIS+MSSQL+ASP.NET
Front-end системы (веб-сайт [www.timera.com](http://www.timera.com)) предоставляет пользователю возможность просматривать фотографии других пользователей, а так же оснащен функционалом социальной сети: присутствует возможность ставить лайки, оставлять комментарии, есть функция Поделиться в других социальных сетях. Так же у пользователя веб-сайта есть возможность загрузить старое фото. Что это значит, и для чего это нужно? Об этом далее.
Помимо веб-сайта неотъемлемую часть архитектуры составляет мобильное приложение. На сегодняшний день оно имплементировано для двух наиболее популярных платформ – это конечно же Android и iOS. Функционал приложения практически полностью воспроизводит функционал веб-сайта, за исключением единственной особенности, которой у веб-сайта быть не может. Речь идет о таймераграфии.
Термин «таймераграфия» используется для обозначения жанра исторического коллажа. Он не новый. Ведь эти работы давно гуляют по интернету и многие из них стали очень вирусными. Стоит только вспомнить проект Сергея Ларенкова «Связь времен» или Шона Клавера с его слайд-шоу о землетрясении в Сан-Франциско в 1906 году. Собственно, название приложения придумал Девид Вебб, основатель проекта, просто сократив термин «таймераграфия». Сейчас самое время немного пояснить саму механику таймераграфии и то, как этот процесс реализован в мобильном приложении Timera.
Предположим, у нас есть старая фотография Эйфелевой башни. Мне лично нравится фотография 1889 года, на которой башня построена лишь до первого уровня. Чтобы создать timera-снимок, нужно найти ракурс, с которого была создана старая фотография, сделать снимок, «перегнать» на компьютер, и в каком-нибудь графическом редакторе произвести совмещение, используя различные фильтры и градиенты. Задачка, скажем, не каждому по силам. Но зато она по силам каждому пользователю приложения Timera. Весь процесс максимально упрощен и даже может показаться весьма забавным (по крайней мере лично я его таковым и считаю).
Пользователь открывает экран с картой, на которой синими пинами отображаются старые фотографии доступные в том или ином месте. Естественно, приложение дает возможность автоматического местоположения пользователя и отображения объектов вокруг. После того, как пользователь определился с тем, что он будет таймераграфировать, запускается экран с камерой. На этом экране присутствует одновременно живое изображение с камеры и поверх нее полупрозрачное изображение старой фотографии (степень прозрачности можно менять). Пользователь может двигать старую фотографию по экрану, менять ее размер с помощью возможностей touch-screen технологии, таким образом производить первичное прицеливание. После того, как снимок сделан, открывается экран более точного совмещения.
 
Самое интересное начинается на третьем экране, где производится настройка time-tunnel (тайм-туннеля). Здесь пользователю доступен тулбар с различными инструментами, такими как:
— слайдеры прозрачности и резкости границы тайм-тоннеля (transparency and softness)
— поворот тайм-тоннеля вокруг оси
— функция, которая получила название swap (поменять местами старую и новую фотографии, то есть старая уходит на задний план, а новая на передний)
— изменение формы тайм-тоннеля: эллиптический или прямоугольный
— обрезка (crop)
Во всех режимах доступно изменение размера и положения тайм-туннеля с помощью экранных жестов.
Казалось бы негусто? Возможно, но даже с этим набором инструментов создаются очень неплохие композиции. И плюс ко всему, планируется расширять данный функционал, идей по этому поводу хватает.
После редактирования возникает получившееся изображение можно загрузить на сервер и/или расшарить в соцсети. При загрузке на сервер можно установить флаг приватности, если нет желания делать свое произведение достоянием общественности.
Здесь хотелось бы рассказать немного нюансов о сложностях, возникших при создании основного use-case (таймераграфировнии).
Во-первых, неприятной неожиданностью стало наличие двух значений типа UIDeviceOrientation. В прошлом мне доводилось работать с iOS-акселерометром и концепцией ориентации устройства, и тогда количество возможных ориентаций устройства равнялось четырем: UIDeviceOrientationPortrait, UIDeviceOrientationPortraitUpsideDown, UIDeviceOrientationLandscapeLeft, UIDeviceOrientationLandscapeRight. На экране фотографирования ориентация устройства весьма критична, поскольку overlay-изображение необходимо ориентировать соответствующим образом, чтоб старая фотка в итоге не получилась вверх ногами, или лежащей на боку. Как выяснилось, существует еще два положения устройства: UIDeviceOrientationFaceUp и UIDeviceOrientationFaceDown. Немало человекочасов ушло, чтобы осознать этот факт и распознать в нем причину неадекватного поведения программы.
Другим интересным моментом, связанным с экраном фотографирования, была проблема с кнопками громкости на боковой поверхности девайса: в стандартном приложении Камера нажатие на кнопки громкости приводит к срабатыванию затвора, что является весьма удобным.
Далее дело техники. По какой-то причине, на нашем экране фотографирования эти кнопки не вызывали никакой реакции, какие бы ухищрения нами не производились, не помогало даже принудительное «прослушивание» нотификаций от медиа-системы.
Делается это примерно так. ViewController подписывается на получение уведомлений об изменении громкости.
`[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(volumeChanged:)
name:@"AVSystemController_SystemVolumeDidChangeNotification"
object:nil];`
Как выяснилось позже, связано это с тем, что у нас используется overlayView, на которой пользователь может менять прозрачность старой фотографии, и вообще видеть ее. Такое же точно поведение было обнаружено в других популярных фото-приложениях. В то же время приложения, которые используют стандартные контролы для фотографирования не страдают от отсутствия реакции на нажатие кнопок громкости.
Наибольшее время разработки ушло на реализацию экрана с эффектами тайм-туннеля. Алгоритм тайм-туннеля основан на методе вычитания градиентного трафарета из исходного изображения: чем темнее пиксель изображения на маске, тем меньше значение прозрачности одноименного пикселя маскируемого изображения. Вся магия реализована при помощи стандартного фреймворка CoreGraphics и функции CGImageCreateWithMask, которой передаются на вход два вышеупомянутых изображения в виде CGImageRef объектов.
Формирование таймераграфии происходит в три этапа. Условимся использовать для изображения на заднем плане обозначение «Изображение А», а для изображения на переднем плане «Изображение Б».
1. Отрисовывается прямоугольная маска с градиентными краями и применяться к Изображению Б. Это было сделано, чтобы временной туннель нигде резко не обрывался. Следует упомянуть, что пользователь имеет возможность повернуть «Изображение Б», например, если горизонт завален. Таким образом, маска формируется исходя из следующих параметров: размер «Изображения Б», угол поворота «Изображения Б», величина размытости границы (регулируется слайдером). Полученная маска вычитается из «Изображения Б», в итоге получается «Изображение Б» с размытыми краями.
Изрядно пришлось повозиться с разворотом градиента, который осуществлялся при помощи все того же CoreGraphics через преобразования матрицы координат графического контекста:
`CGFloat angleInRadians = angle * (M_PI / 180);
CGContextRotateCTM(bmContext, angleInRadians);`
При этом возникал неожиданный эффект, как выяснилось позже, из-за того, что по умолчанию разворот производится вокруг верхнего левого угла изображения.
Я даже задал вопрос на stackoverflow, после безуспешных поисков подсказки. Однако, не получив ответа, нашел решение эмпирическим путем, и оставил ответ на собственный вопрос (http://stackoverflow.com/questions/19219855/uiimageview-get-transformed-uiimage)
Другой неожиданностью стало отсутствие готового способа отрисовать прямоугольный градиент для маски (такой, как на иллюстрации). Для эллиптического решение в CoreGraphics есть, а вот именно для прямоугольного, со скругленными краями, пришлось изобретать (http://stackoverflow.com/questions/18918382/coregraphics-rectangle-gradient – еще один само ответ).
2. Отрисовывается градиентная маска и применяется к «Изображению Б», полученному в результате обработки на первом этапе. В отличие от первого этапа пользователь может задавать вид маски: прямоугольный или эллиптический плюс те же самые размеры маски, угол поворота, степень размытости границы. Размеры маски и положение пользователь меняет пальцами на экране. Таким образом формируется изображение тайм-туннеля.
3. На последнем этапе полученное изображение тайм-туннеля отрисовывается в нужных координатах на «Изображении А»
Должен заметить, что CoreGraphics далеко не самая производительная вещь на свете, и особенно это заметно на старых девайсах, начиная с iPhone 4 и ниже. В связи с этим был принят ряд мер по оптимизации функционала таймераграфии. Но об этом и многом другом во второй части.
Надеюсь, я вас заинтересовал. [Качайте приложение](https://itunes.apple.com/app/timera/id786222310?mt=8), оценивайте и пишите фидбек.
Если понравилось, не откажусь от инвайта. Буду отвечать на комментарии и публиковать со своего аккаунта.
Жду вопросы и комментарии. | https://habr.com/ru/post/212497/ | null | ru | null |
# Виртуальный хостинг для Django (FreeBSD + Apache + mod_python / mod_wsgi)
Создавая новый проект на Django, ты в очередной раз лезешь изменять конфигурации своего web-сервера. И вроде бы ничего страшного, да только конфигурации ты меняешь уже чаще, чем выгуливаешь свою собаку. Как-то не правильно? Согласен (собака, думаю, тоже не возражает). Выход – виртуальный хостинг. Изучив пару статей в Интернете, ты забиваешь конфигурации своих сайтов в httpd-vhosts.conf. И какое-то время даже радуешься этому. Проходит время и на локальном хосте у тебя уже не два с половиной сайта, а десятки проектов (пусть даже небольших). И, открывая в очередной раз httpd-vhosts.conf, чтобы добавить какую-нибудь опцию, ты начинаешь думать «А был ли мальчик?», действительно ли ты создавал этот сайт? Ведь в такой окрошке из проектов уже нелегко что-либо отыскать. А если еще учесть, что половина проектов взаимодействует с web-сервером при помощи модуля mod\_python, а другая – при помощи модуля mod\_wsgi, например, тогда вообще становится грустно работать. Да и жить тоже становится грустно (а уж как ваша собака то у дверей грустит).
Тут я попробую рассказать, как сделать виртуальный хостинг более дружелюбным, а заодно и как настроить вышеупомянутые модули (mod\_python и mod\_wsgi).
Я не думаю, что открываю Америку своими соображениями на этот счет. Но, буду рад, если кому-нибудь мои примеры помогут уменьшить время, потраченное на настройку данной конфигурации, и провести его с большей пользой для себя (или для своей собаки).
Итак, попробую описать то, что у меня есть, и что должно получиться в конце моего сольного выступления. На операционной системе FreeBSD 9.0 установлены Python 2.7, Django 1.3 и web-сервер Apache 2.2. В моем домашнем каталоге содержатся два django-проекта, готовые к употреблению. Дело за малым – необходимо выбрать и установить модуль для взаимодействия Apache и Django, а также настроить виртуальный хостинг для одновременного управления несколькими django-проектами. Вот мое дерево каталогов, полученное при помощи команды tree:
Для развертывания Django на сервере необходима установка и настройка модуля, взаимодействующего с web-сервером. Таких модулей существует несколько. Какому отдать свое предпочтение – зависит от свойств и характеристик системы, опыта и психологических особенностей лица, осуществляющего выбор, степени его вменяемости, кривизны устройства /dev/hands, погоды на улице и т.д. Проще говоря, дело вкуса. Уверен, что у каждого найдется масса доводов в поддержку своего любимого модуля. Не буду спорить, так как не хотелось бы выслушивать их все. Приведу лишь настройку тех модулей, с которыми мне приходилось взаимодействовать.
Сразу хочу заметить, что я действую от лица суперпользователя, поэтому в моих листингах отсутствуют команды типа su или sudo. Прошу не забывать про эти волшебные слова тех, кто настраивает систему под аккаунтом менее привилегированного пользователя.
Итак, поехали!
### MOD\_PYTHON
Web-сервер Apache c модулем mod\_python исторически всегда считался основной рабочей средой для Django (именно эту комбинацию использовали создатели платформы Django в качестве основы своих высоко нагруженных новостных сайтов). Этот модуль реализует интерпретатор языка Python внутри web-сервера и загружает написанный на Python код в момент запуска сервера. Код остается в памяти все время, пока процесс Apache работает. Такая связка Apache+mod\_python и по сей день представляет собой хорошо протестированный и хорошо документированный вариант развертывания. Но, данный модуль уже морально устарел, и его поддержка будет удалена в Django 1.5. Поэтому, на [официальном сайте Django](https://docs.djangoproject.com/en/dev/howto/deployment/modpython/) настоятельно рекомендуют при развертывании нового проекта рассмотреть вопрос об использовании модуля mod\_wsgi (тему которого мы затронем чуть ниже в этой статье).
Итак, mod\_python. Сам модуль есть в портах, поэтому установим его оттуда:
```
# cd /usr/ports/www/mod_python3
# make install clean
```
После установки модуль добавляет свои параметры настройки в конфигурационный файл Apache — httpd.conf. Если вы используете систему управления версиями для сохранения файла httpd.conf (как и должно быть «в нормальной семье»), значит, перед установкой порта не забудьте захватить файл.
Далее открываем для редактирования вышеупомянутый httpd.conf (лично я пользуюсь редактором ee, но вы можете использовать и что-нибудь в корне другое, типа vi):
```
# ee /usr/local/etc/apache22/httpd.conf
```
Необходимо проверить наличие в этом файле следующих строк:
1. ```
LoadModule python_module libexec/apache22/mod_python.so
```
(загрузка модуля mod\_python. Это та строка, которая должна была добавиться в файл автоматически на предыдущем шаге.)
2. ```
User www
Group www
```
(запуск сервера от лица непривилегированного пользователя. Хотя иногда встречаются рекомендации запускать Apache от имени root, не стоит поступать так. Если злоумышленник взломает ваш web-сервер, в качестве дополнительной награды он получит права root в вашей системе!)
3. ```
ServerName localhost
```
(имя web-сайта. Оно должно представлять собой реальное имя хоста и иметь соответствующую запись в DNS. Однако во время тестирования вместо записи DNS можно применять запись в /etc/hosts. Собственно говоря, так мы и поступим. Поэтому в ServerName я указал localhost. При тестировании на локальном хосте можно вообще не добавлять эту строку, но тогда web-сервер при каждом перезапуске будет подозрительно фыркать в вашу сторону.)
Сразу же, чтобы не забыть, я добавлю запись в /etc/hosts (это имена моих сайтов):
```
127.0.0.1 gallery.ru museum.ru
```
Теперь настроим виртуальный хостинг. В случае виртуального хостинга несколько имен хостов относятся к одной и той же машине. Сервер должен различать запросы к различным доменам, а затем предоставлять соответствующие страницы. Чтобы включить функцию обслуживания виртуальных хостов, можно раскомментировать строку Include etc/apache22/extra/httpd vhosts.conf в файле httpd.conf и писать конфигурации всех наших сайтов в один файл httpd-vhosts.conf (о чем рассказывалось выше). Но, поскольку единственный сервер Apache в состоянии обслуживать довольно приличное количество виртуальных хостов, то намного удобнее хранить конфигурацию каждого такого хоста в отдельном файле в каталоге Includes (/usr/local/etc/apache22/Includes). Если имя файла, содержащегося в этом каталоге, имеет расширение .conf, тогда Apache автоматически подключает конфигурацию из этого файла при последующих перезагрузках. Кроме того, чтобы не потеряться во множестве файлов, мы будем присваивать им имена, содержащие имена доменов, которые они будут обслуживать.
Итак, в конец файла httpd.conf добавим следующие инструкции:
```
Include etc/apache22/ Includes/*.conf
NameVirtualHost *
```
Затем в папке Includes создадим файлы с названиями наших будущих сайтов:
```
# cd /usr/local/etc/apache22/Includes
# touch gallery.ru.conf
# touch museum.ru.conf
```
Все что нам осталось теперь, это внести конфигурационные настройки во вновь созданные файлы. Приведу листинг только файла gallery.ru.conf:
```
ServerName gallery.ru
ServerAlias www.gallery.ru
ServerAdmin test@test.ru
DocumentRoot /home/valera/djcode/gallery
SetHandler python-program
PythonHandler django.core.handlers.modpython
SetEnv DJANGO\_SETTINGS\_MODULE gallery.settings
PythonDebug On
PythonPath "['/home/valera/djcode'] + sys.path"
SetHandler None
Order allow,deny
Allow from 127.0.
```
Аналогичным образом заполняется файл museum.ru.conf и все последующие конфигурации ваших сайтов. В проекте museum.ru я не использую изображения, поэтому следующие строки в его конфиг не включаются:
```
SetHandler None
```
Вот собственно и все дела. Единственное, что хотелось бы напомнить, что у web-сервера должен быть доступ на запись к каталогу, в котором содержатся файлы изображений, js-скрипты и прочее (в моем случае это папка media). Для этого в каталоге, содержащем папку media, выполним следующие инструкции:
```
# chgrp www media
# chmod g+w media
```
Перезапускаем сервер:
```
# /usr/local/etc/rc.d/apache22 restart
```
Вводим в строке браузера имя нашего сайта (в моем случае gallery.ru или museum.ru) и радуемся за не напрасно потраченное время!
### MOD\_WSGI
Позиционируется как замена mod\_python. Главным достоинством модуля является низкое потребление памяти и высокая производительность по сравнению с mod\_python, а также возможность работы в режиме демона.
Теперь поступим немного проще. Я не буду объяснять, почему в конкретном случае я поступаю так, а не иначе (все ответы можно найти в описании предыдущего модуля), а просто приведу порядок действий и необходимые команды.
Установим модуль из портов:
```
# cd /usr/ports/www/mod_wsgi3
# make install clean
```
Открываем для редактирования httpd.conf:
```
# ee /usr/local/etc/apache22/httpd.conf
```
Проверяем наличие в этом файле следующих строк:
1. ```
LoadModule wsgi_module libexec/apache22/mod_wsgi.so
```
(загрузка модуля mod\_wsgi. Эта строка должна появиться автоматически при установке модуля из портов.)
2. ```
User www
Group www
```
(запуск сервера от лица непривилегированного пользователя)
3. ```
ServerName localhost
```
(имя web-сайта)
Итак, в конец файла httpd.conf добавим следующие инструкции:
```
Include etc/apache22/ Includes/*.conf
NameVirtualHost *
```
Запись в файле /etc/hosts один в один, как и для предыдущего модуля. То есть, в моем случае:
```
127.0.0.1 gallery.ru museum.ru
```
Далее в папке Includes создадим файлы с названиями наших будущих сайтов:
```
# cd /usr/local/etc/apache22/Includes
# touch gallery.ru.conf
# touch museum.ru.conf
```
Теперь внесем конфигурационные настройки во вновь созданные файлы. Приведу листинг только файла gallery.ru.conf:
```
ServerName gallery.ru
ServerAlias www.gallery.ru
ServerAdmin test@test.ru
WSGIScriptAlias / /home/valera/djcode/gallery/mod.wsgi
Alias /media/ /home/valera/djcode/gallery/media/
Order allow,deny
Allow from 127.0.
```
Аналогичным образом заполняется файл museum.ru.conf и все последующие конфигурации ваших сайтов. В проекте museum.ru я не использую изображения, поэтому следующая строка в его конфиг не включаются:
```
Alias /media/ /home/valera/djcode/gallery/media/
```
Осталось только создать упомянутый в листинге файл mod.wsgi:
```
# cd /home/valera/djcode/gallery
# touch mod.wsgi
```
Вот его содержимое:
```
import os, sys
sys.path.append('/home/valera/djcode')
os.environ['DJANGO_SETTINGS_MODULE'] = 'gallery.settings'
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
```
Сделаем каталог media доступным для записи:
```
# chgrp www media
# chmod g+w media
```
Перезапускаем сервер:
```
# /usr/local/etc/rc.d/apache22 restart
```
Вводим в строке браузера имя нашего сайта (в моем случае gallery.ru и museum.ru) и опять-таки радуемся!
### LAST ONE
В итоге мы получаем кучу конфигурационных файлов, отвечающих за наши сайты, в одной единственной папке. При этом все конфиги разбиты по именам, и каждый содержит в себе в среднем не более 30 строк кода. По сравнению с монолитной конфигурацией, когда все параметры настройки сосредоточены в одном файле, такой подход позволяет упростить поиск неполадок на сайте.
Если вам необходимо, чтобы разные сайты взаимодействовали с сервером через разные модули, то вы можете настраивать каждый конфиг тем способом, из приведенных выше, который вам необходим. Главное убедитесь, что загрузка обоих модулей присутствует в файле httpd.conf:
```
LoadModule python_module libexec/apache22/mod_python.so
LoadModule wsgi_module libexec/apache22/mod_wsgi.so
```
Если же вы, как и я, храните все проекты в одном каталоге, то, для создания нового конфига, достаточно поступить следующим образом. Найти конфиг, схожий с тем, который вам предстоит создать. Скопировать его, изменив при этом имя файла. И заменить все, присутствующие в нем, названия старого сайта на названия нового. То есть:
```
# cp old_site.ru.conf new_site.ru.conf
# sed –i –e ‘s/old_site/new_site/g’ new_site.ru.conf
```
В итоге, добавление нового сайта в конфигурацию web-сервера занимает ровно столько времени, сколько необходимо для набора на клавиатуре двух вышеперечисленных команд и перезагрузки сервера (в случае использования модуля mod\_wsgi еще добавляется копирование файла mod.wsgi).
На этом вроде бы закончил. **Хорошего вам дня!**
---
Книги, повлиявшие на ход мыслей в данной статье:
* [М.Лукас “FreeBSD. Подробное руководство”](http://www.symbol.ru/date/611001.html)
* [А.Головатый, Д.Каплан-Мосс “Django. Подробное руководство”](http://www.symbol.ru/alphabet/749548.html)
* [Д.Форсье, П.Биссекс, У.Чан “Django. Разработка web-приложений на Python”](http://www.symbol.ru/alphabet/666336.html) | https://habr.com/ru/post/138830/ | null | ru | null |
# Обнаружение сетевых устройств
Сканирование сети с построением списка устройств и их свойств, таких как перечень сетевых интерфейсов, с последующим снятием данных в системах мониторинга, если не вникать в происходящее, может показаться особой, компьютерной, магией. Как же это работает — под катом.
> **Disclaimer**
>
> Автор не имеет профильного образования, связанного с администрированием сетей, поэтому наверняка имеются неточности и упомянуто не всё, что можно.
>
>
### Обнаружение
Для обнаружения устройства, т.е. определения есть ли на выбранном ip-адресе что-либо, можно применить следующие методы:
* **ping сканирование**
Как ни странно, это самый простой и распространенный способ.
* **Проверка открытых TCP-портов**
Если на устройстве отключен ответ на ping, то можно попробовать установить соединение по какому-либо TCP-порту. В виду того, что портов много и проверка каждого занимает значительное время, обычно проверяются только самые распространенные, напр. 80 или 443, используемые для веб-интерфейса устройства.
* **Проверка работы UDP служб**
UDP протокол не отправляет подтверждения о получении запроса и поэтому в общем виде сканирование UDP-портов невозможно. Однако можно попробовать опросить службы, прослушивающие UDP-порт и отправляющие ответ на запрос, напр. [SNMP](https://ru.wikipedia.org/wiki/SNMP) (порт 161) или [IPMI](https://ru.wikipedia.org/wiki/Intelligent_Platform_Management_Interface) (порт 623). В случае, если получен ответ, отличный от таймаута, то устройство обнаружено.
* **ARP сканирование**
Помимо обычных [ICMP](https://ru.wikipedia.org/wiki/ICMP) запросов, которые используют утилиты ping, для устройств в том же широковещательном L2-домене можно воспользоваться более быстрым [arping](https://ru.wikipedia.org/wiki/Arping): по диапазону ip-адресов рассылаются широковещательные [ARP](https://ru.wikipedia.org/wiki/ARP) пакеты вида «компьютер с IP-адресом XXX, сообщите свой MAC-адрес компьютеру с МАС-адресом запросившего», и если ответ получен, то устройство считается обнаруженным.
* **CDP/LLDP**
Если в сети используется протокол [LLDP](https://ru.wikipedia.org/wiki/LLDP) (или аналог CDP), то устройства могут собирать сведения о своих соседях, которые можно считать обнаруженными. Эти данные доступны по SNMP.
Отмечу, что информация о соседях совместно с результатами `traceroute` может служить основой для построения физической карты сети.
* **NetBIOS сканирование**
Протокол [NetBIOS](https://ru.wikipedia.org/wiki/NetBIOS) может быть использован для поиска Windows-машин, например при помощи утилиты `nbtscan`.
* **Журналы DHCP** (предложено [alexanster](https://habrahabr.ru/users/alexanster/))
В журналах DHCP-серверов есть информация о выдачи ip-адресов по MAC-адресам. Для недавних записей в журнале можно считать, что эти устройства обнаружены.
* **ARPWatch** (предложено [alexanster](https://habrahabr.ru/users/alexanster/), описано [TaHKucT](https://habrahabr.ru/users/tahkuct/))
Arpwatch отслеживает пары IP-адрес — MAC-адрес, записывая в лог новые, пропавшие и изменившиеся пары. Устройства, попавшие в лог, можно считать обнаруженными.
* **Анализ FDB-таблиц коммутаторов**(предложено [mickvav](https://habrahabr.ru/users/mickvav/))
FDB-таблицы (Forwarding DataBase) управляемых коммутаторов содержат данные о коммутации MAC-адресов абонентов и устройств, т.е. соответствии MAC-адрес устройства — порт коммутатора.
Данные доступны по [SNMP](https://habrahabr.ru/post/213247/) и telnet, и могут быть использованы при построении физической карты сети.
### Сбор сведений
После того, как устройство обнаружено, можно переходить к сбору сведений о нем.
Используя ARP протокол, по ip можно получить MAC-адрес, а по нему вероятного производителя (часть оборудования допускает смену адреса, так что метод не очень надежен). Далее можно воспользоваться утилитой [nmap](https://ru.wikipedia.org/wiki/Nmap), которая сканируя открытые порты, сверяется со своей базой отпечатков и [делает предположение](https://nmap.org/man/ru/man-os-detection.html) об используемой операционной системе, её версии и типе устройства.
**Получение типа устройства и используемой ОС при помощи nmap**
```
nmap -O -v 192.168.0.1
Starting Nmap 7.60 ( https://nmap.org ) at 2018-03-04 01:17 RTZ 2 (ceia)
Initiating ARP Ping Scan at 01:17
Scanning 192.168.0.1 [1 port]
Completed ARP Ping Scan at 01:17, 0.70s elapsed (1 total hosts)
Initiating Parallel DNS resolution of 1 host. at 01:17
Completed Parallel DNS resolution of 1 host. at 01:17, 0.00s elapsed
Initiating SYN Stealth Scan at 01:17
Scanning 192.168.0.1 [1000 ports]
Discovered open port 80/tcp on 192.168.0.1
Discovered open port 49152/tcp on 192.168.0.1
Discovered open port 1900/tcp on 192.168.0.1
Completed SYN Stealth Scan at 01:17, 0.13s elapsed (1000 total ports)
Initiating OS detection (try #1) against 192.168.0.1
Retrying OS detection (try #2) against 192.168.0.1
WARNING: OS didn't match until try #2
Nmap scan report for 192.168.0.1
Host is up (0.00s latency).
Not shown: 997 closed ports
PORT STATE SERVICE
80/tcp open http
1900/tcp open upnp
49152/tcp open unknown
MAC Address: A0:F3:C1:35:21:58 (Tp-link Technologies)
Device type: WAP
Running: Linux 2.4.X
OS CPE: cpe:/o:linux:linux_kernel:2.4.36
OS details: DD-WRT v24-sp1 (Linux 2.4.36)
Network Distance: 1 hop
```
Чтобы получить более подробные сведения по устройству потребуется один из следующих способов:
* **SNMP**
Протокол [SNMP](https://ru.wikipedia.org/wiki/SNMP) почти всегда поддерживаем маршрутизаторами и коммутаторами; имеется в Windows (соответствующая служба по умолчанию отключена); для Linux требуется установка демона snmpd. По всей видимости последняя третья версия достаточно сложна в реализации, поэтому предыдущая версия 2с до сих пор актуальна, хотя и не рекомендуема из-за отсутсвия шифрования при передаче данных. Протолок работает на 161 UDP-порту устройства.
Для работы с SNMP можно использовать пакет утилит [Net-SNMP](http://www.net-snmp.org/). Чтобы получить, к примеру, описание устройства, надо указать версию протокола, пароль на чтение (community read, по умолчанию public) и адрес, в нотации SNMP называемый OID (object identificator) и состоящий из чисел и точек. Все адреса устройства можно представить в виде дерева, где адреса отсортированы в лексикографическом порядке. Протокол позволяет запросить текущее значение по адресу, а также адреса следующие за текущим.
**Получение описания устройства при помощи snmpget**
```
snmpget -v 2c -c public 192.168.0.102 1.3.6.1.2.1.1.1.0
SNMPv2-MIB::sysDescr.0 = STRING: Linux debian 3.16.0-4-586 #1 Debian 3.16.43-2+deb8u2 (2017-06-26) i686
```
Стандартный набор адресов весьма ограничен и содержит описание устройства, контакты, расположение и время работы (uptime). Остальные адреса зависят от производителя устройства и могут быть получены сканированием, например, утилитой snmpwalk. К счастью, Linux и Windows имеют типовые адреса для сетевых интерфейсов и загруженности процессоров/памяти, поэтому для них лишь знать (или уметь определить) используемую операционную систему.
**Получение описания дисков Linux при помощи snmpwalk**
```
snmpwalk -v 2c -c public 192.168.0.102 1.3.6.1.4.1.2021.9.1.2
UCD-SNMP-MIB::dskPath.1 = STRING: /
UCD-SNMP-MIB::dskPath.2 = STRING: /var
UCD-SNMP-MIB::dskPath.3 = STRING: /
UCD-SNMP-MIB::dskPath.4 = STRING: /run
UCD-SNMP-MIB::dskPath.5 = STRING: /dev/shm
UCD-SNMP-MIB::dskPath.6 = STRING: /run/lock
UCD-SNMP-MIB::dskPath.7 = STRING: /sys/fs/cgroup
```
**Получение описания дисков Windows при помощи snmpwalk**
```
snmpwalk -v 2c -c public localhost 1.3.6.1.2.1.25.2.3.1.3
HOST-RESOURCES-MIB::hrStorageDescr.1 = STRING: C:\ Label: Serial Number a65ceb77
HOST-RESOURCES-MIB::hrStorageDescr.2 = STRING: D:\ Label: Serial Number ded9f83e
HOST-RESOURCES-MIB::hrStorageDescr.3 = STRING: E:\ Label: Serial Number 8e764a1
HOST-RESOURCES-MIB::hrStorageDescr.4 = STRING: I:\
HOST-RESOURCES-MIB::hrStorageDescr.5 = STRING: Virtual Memory
HOST-RESOURCES-MIB::hrStorageDescr.6 = STRING: Physical Memory
```
* **WMI**
Технология [WMI](https://ru.wikipedia.org/wiki/WMI) — это расширенная и адаптированная под Windows реализация стандарта [WBEM](https://en.wikipedia.org/wiki/Web-Based_Enterprise_Management), позволяющая удаленно не только считывать параметры, но и управлять устройством. WMI работает поверх [RPC](https://ru.wikipedia.org/wiki/%D0%A3%D0%B4%D0%B0%D0%BB%D1%91%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D0%B4%D1%83%D1%80) (TCP порт 135) и [DCOM](https://ru.wikipedia.org/wiki/DCOM) (на произвольном TCP порту выше 1024), активно используется в скриптах [Power Shell](https://ru.wikipedia.org/wiki/Windows_PowerShell) (ранее Windows Script Host).
Данные можно запрашивать, разумеется, только с Windows машин.
**Получение информации об оперативной памяти в PowerShell**
```
Get-WmiObject win32_OperatingSystem |%{"Total Physical Memory: {0}KB`nFree Physical Memory : {1}KB`nTotal Virtual Memory : {2}KB`nFree Virtual Memory : {3}KB" -f $_.totalvisiblememorysize, $_.freephysicalmemory, $_.totalvirtualmemorysize, $_.freevirtualmemory}
Total Physical Memory: 2882040KB
Free Physical Memory : 612912KB
Total Virtual Memory : 5762364KB
Free Virtual Memory : 1778140KB
```
Также имеется консольная утилита [wmic](https://blogs.technet.microsoft.com/askperf/2012/02/17/useful-wmic-queries/) и ее [Linux-порт](https://www.krenger.ch/blog/wmi-commands-from-linux/)
**Получение производителя устройства при помощи wmic**
```
wmic /USER:admin /PASSWORD:mypassword /NODE:"192.168.0.100" computersystem get Manufacturer
Manufacturer
Gigabyte Technology Co., Ltd.
```
* **Агент системы мониторинга, напр. Zabbix или Check\_MK**
Если имеется возможность, то на устройстве устанавливается небольшая программа, работающая в фоне и собирающая данные. Преимущество использования агентов в том, что получение данных унифицировано вне зависимости от используемого устройством оборудования и операционной системы, а также возможно собирать данные доступные только локально (к примеру результат работы консольной программы).
* **SSH**
Исходно данные по [SSH](https://ru.wikipedia.org/wiki/SSH) можно получать с Linux и iOS устройств. Для Windows и Android потребуется установка SSH-сервера.
**Получение информации о CPU по SSH**
```
cat /proc/cpuinfo
processor : 0
Processor : AArch64 Processor rev 4 (aarch64)
Hardware : sun50iw1p1
BogoMIPS : 48.00
Features : fp asimd evtstrm aes pmull sha1 sha2 crc32 cpuid
CPU implementer : 0x41
CPU architecture: 8
CPU variant : 0x0
CPU part : 0xd03
CPU revision : 4
processor : 1
...
```
* **Запрос данных у управляющего сервиса**, такого как [гипервизор](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D0%BF%D0%B5%D1%80%D0%B2%D0%B8%D0%B7%D0%BE%D1%80) виртуальных машин
### Как это работает на примере Zabbix
Как известно [Zabbix](https://ru.wikipedia.org/wiki/Zabbix) может самостоятельно обнаруживать новые устройства в сети и автоматически опрашивать некоторые их параметры. Называется это — [Low Level Discovery](https://www.zabbix.com/documentation/4.0/ru/manual/discovery/low_level_discovery).
Обнаружение устройств задается [правилами сетевого обнаружения](https://www.zabbix.com/documentation/4.0/ru/manual/discovery/network_discovery/rule), которые комбинируют перечисленные ранее методы обнаружения, определяют доступно ли устройство и какой шаблон к нему применить (обычно исследуется описание устройства). Шаблон содержит список свойств, которые можно получить с устройства, а также правила для обнаружения и создания новых, выполняемые по таймеру.
В случае с SNMP такое правило может выглядеть примерно так: перебрать все дочерние элементы узла `1.3.6.1.2.1.2.2.1.8` (правило обнаружения) и для каждого найденного элемента (число, помещаемое в `{#SNMPINDEX}`) добавить новые метрики, задаваемые через прототипы элементов данных, `1.3.6.1.2.1.2.2.1.10.{#SNMPINDEX}` и `1.3.6.1.2.1.2.2.1.16.{#SNMPINDEX}`, если их еще нет. Подробнее [здесь](https://habrahabr.ru/company/zabbix/blog/193460/).
В случае агента правило будет выглядеть немного иначе: запросить у агента одно из discovery-свойств, к примеру `system.cpu.discovery`, получить список процессоров в виде json
```
[
{"NUMBER": 0, "STATUS": "online"},
{"NUMBER": 1, "STATUS": "online"}
]
```
и для каждого элемента добавить `system.cpu.load[{#CPU.NUMBER}]`, если такой метрики еще нет. Стоит отметить, что Zabbix-агент позволяет создавать свои элементы (`UserParameter`), которые могут быть запрошены, и поэтому легко можно реализовать, например, обнаружение файлов и отслеживание их размера в заданной папке. Подробнее [здесь](https://habrahabr.ru/post/194980/).
### Заключение
Как видно всё достаточно просто и никакой магии нет. Если вы знаете еще какие-либо способы обнаружения устройств или получения их свойств, то просьба сообщить о них. | https://habr.com/ru/post/350394/ | null | ru | null |
# Избавление Kohana ORM от лишних запросов к БД
ORM, несомненно, мощная и удобная вещь, но запросы генерируются не только не всегда оптимальные, но еще и лишние. При создании объекта модели ORM должен знать информацию о всех полях соответствующей таблицы БД. Что приводит к нежелательным запросам к БД.
#### Проблема
При создании объекта модели с помощью ORM выполняется запрос *SHOW FULL COLUMNS FROM `tablename`* и заполняется поле объекта *protected $\_table\_columns* массивом с данными о полях.
```
protected _table_columns => array(8) (
"id" => array(4) (
"type" => string(3) "int"
"is_nullable" => bool FALSE
)
"email" => array(4) (
"type" => string(6) "string"
"is_nullable" => bool FALSE
)
...
```
На скриншоте видно последний запрос к БД (кликабельно)
[](http://www.habrastorage.com/images/20120913iv.png)
Причем ORM::factory() каждый раз создает новый экземпляр объекта и, следовательно, вызов подряд нескольких методов с помощью конструкции
```
ORM::factory('model_name')->method_1()
ORM::factory('model_name')->method_2()
```
генерирует 2 одинаковых запроса *SHOW FULL COLUMNS FROM* (даже если *$\_table\_columns* вообще не понадобятся в конкретном случае). Также загрузка связанных моделей генерирует запросы для каждой из моделей — вызов *ORM::factory('user')->with('profile')->with('photo')*. Выходит каждый второй запрос к БД в проекте (активно использующем ORM) — *SHOW FULL COLUMNS FROM*.
#### Одно из решений
Решение проблемы очень простое, но почему-то нигде не описанное — заполнить вручную этот массив в каждой модели (естественно в конце разработки проекта). Попытка заполнить его в ручную для нескольких десятков больших таблиц подобна выстрелу себе в ногу. Поэтому за несколько часов было найдено универсальное решение — написать класс Optimize, который рекурсивно проходится по папке с моделями, выбирает содержащие запись *extends ORM* и не содержащие запись *protected $\_table\_columns* и генерирует для модели этот массив используя *ORM::factory('model')->list\_columns()* и немного переделанный «родной» метод Debug::vars();
**Код самого класса — под спойлером**
**смотреть код класса Optimize**
```
class Optimize{
private static $files = array();
/**
* Returns database tables columns list
*
* @uses find_models()
* @uses _dump_simple()
*/
public static function list_columns()
{
$dir = APPPATH . "classes/model";
self::find_models($dir);
foreach (self::$files as $model) {
$file_text = file_get_contents($model);
if(preg_match('/extends +ORM/i', $file_text) && !preg_match('/_table_columns/i', $file_text)){
preg_match("/(class\sModel_)(\w+)?(\sextends)/", $file_text, $match);
$model_name = preg_replace("/(class\sModel_)(.*?)(\sextends)/", "$2", $match[0]);
echo '### Model\_'.ucfirst($model\_name).'
';
$columns[] = ORM::factory(strtolower($model_name))->list_columns();
$output = array();
foreach ($columns as $var) {
$output[] = self::_dump_simple($var, 1024);
}
echo '
```
protected $_table_columns = ' . substr(implode("\n", $output), 0, -1) . ';
```
';
echo '========================================================';
}
}
}
public static function find_models($in_dir)
{
if (preg_match("/_vti[.]*/i", $in_dir)) {
return;
}
if ($dir_handle = @opendir($in_dir)) {
while ($file = readdir($dir_handle)) {
$path = $in_dir . "/" . $file;
if ($file != ".." && $file != "." && is_dir($path) && $file != '.svn') {
self::find_models($path);
}
if (is_file($path) && $file != ".." && $file != "." && strtolower(substr(strrchr($path, '.'), 1))=='php') {
self::$files[] = $path;
}
}
}
}
protected static function _dump_simple(& $var, $length = 128, $limit = 10, $level = 0)
{
if ($var === NULL) {
return 'NULL,';
}
elseif (is_bool($var)) {
return ($var ? 'TRUE' : 'FALSE') . ',';
}
elseif (is_float($var)) {
return $var . ',';
}
elseif (is_string($var)) {
return "'" . $var . "',";
}
elseif (is_array($var)) {
$output = array();
$space = str_repeat($s = ' ', $level);
static $marker;
if ($marker === NULL) {
$marker = uniqid("\x00");
}
if ($level < $limit) {
$output[] = "array(";
$var[$marker] = TRUE;
foreach ($var as $key => & $val) {
if ($level == 1 && !in_array($key, array('type', 'is_nullable')))
continue;
if ($key === $marker)
continue;
if (!is_int($key)) {
$key = "'" . htmlspecialchars($key, ENT_NOQUOTES, Kohana::$charset) . "'";
}
$output[] = "$space$s$key => " . self::_dump_simple($val, $length, $limit, $level + 1);
}
unset($var[$marker]);
$output[] = "$space),";
}
return implode("\n", $output);
}
else {
return htmlspecialchars(print_r($var, TRUE), ENT_NOQUOTES, Kohana::$charset) . ',';
}
}
} // End Optimize
```
Запись массива с полями автоматически в код класса модели было решено не делать — все равно с форматированием кода не угадаешь. Поэтому все выводится на экран в виде:
```
Model_Option
protected $_table_columns = array(
'id' => array(
'type' => 'int',
'is_nullable' => FALSE,
),
'name' => array(
'type' => 'string',
'is_nullable' => FALSE,
),
```
Сам класс (размещать в /application/classes/optimize.php ). Вызов метода из любого места:
```
echo Optimize::list_columns();
```
Доказательство работы метода — отсутвие last\_query в распечатанном объекте модели.
[](http://cdn.habrastorage.com/images/20120913b2.png)
Другие найденные рещения — [blogocms.ru/2011/05/kohana-uskoryaem-orm](http://blogocms.ru/2011/05/kohana-uskoryaem-orm/) — кеширование структуры таблиц. Более просто решение, но и менее оптимальное по скорости.
#### Профилирование и тесты
Была произведена попытка измерения скорости (на точность измерений не претендую). Напишем небольшой синтетический тест
```
$token = Profiler::start('Model', 'User');
ORM::factory('user')->with('profile')->with('profile:file');
Profiler::stop($token);
echo View::factory('profiler/stats');
```
И запустим его 10 раз. Получаем что без заполения массивов *$\_table\_columns* в среднем на всю работу фреймворка уходит 0.15 сек из них 0.005 сек. на запросы SHOW FULL COLUMNS FROM.
С заполненным *$\_table\_columns* — в среднем 0.145 сек. Прирост **3.3%**
Напишем более реальный тест c выборкой нескольких записей и использованием связанных моделей.
```
$token = Profiler::start('Model', 'User');
for ($index = 0; $index < 10; $index++) {
ORM::factory('user')->with('profile')->with('profile:file')->get_user(array(rand(1,100), rand(1,100)));
}
Profiler::stop($token);
echo View::factory('profiler/stats');
```
Без заполения массивов *$\_table\_columns* в среднем на всю работу фреймворка уходит 0.18 сек из них 0.015 сек. на запросы к БД на заполение массивов полями таблиц. Следовательно прирост поменьше — **2.8%**
Конечно в реальном проекте цифры будут сильно зависеть от самого кода и работы с ORM. Ожидаемое уменьшение количества запросов к БД — 1.5 — 3 раза в проекте использующем ORM, что очень разгрузит сервер MySQL. Но запросы повторяются одинаковые и кешируются MySQL — поэтому конкретный прирост скорости будет в районе 2-3%.
Явный минус решения один — на проекте, который работает на лайв сервере и параллельно активно разрабатывается — нужно дописывать каждое новое поле в массив *$\_table\_columns* вручную, а для новых таблиц генерировать весь массив.
P.S. Соавтор статьи — [unix44](http://habrahabr.ru/users/unix44/), кто не жадный — может дать инвайт. | https://habr.com/ru/post/154865/ | null | ru | null |
# Об использование sed1335 в микроконтроллерах stm32f103
Ни для кого не секрет что одним из основных интересов вывода информации у приборов является дисплей. В основном на МК подключат символьные дисплеи на основе hd44780. Редким исключением составляется графические дисплеи графические дисплеи WG12864A разрешением 128\*64. Но что делать если нужно больше.
И вот я заказал дисплей WG320240B0-FFH-VZ-000. [Даташит](http://rghost.ru/57471120).
Предложил эту модель мне поставщик. Я сразу не проверил. Подсветка идет LCD. Нужно выбирать LED, так как найти драйвер DC-AC я так и не смог.
Дисплей заказан, пора его чем то заводить. В качестве буфера применил stm32f103.
Тут началось гугление. На русском языке я особо ничего так и не нашел.
Но понял что надо копать в сторону
**SED1335**SED1335F-многоцелевая интегральная схема контролера ЖКД, который может показывать текст и графику на жидкокристаллическом дисплее средних размеров. S-MOS рекомендует, чтобы в новых проектах использовались SED1335, так как SED1330 будет постепенно заменены на SED1335.
На брел я на сайт [en.radzio.dxp.pl/ssd1963](http://en.radzio.dxp.pl/ssd1963/) где была скачана библиотека sed1335lib.zip
Добавил я в свой проект
```
graphic.c
graphic.h
SED1335-STM32.c
sed1335.c
sed1335.h
```
в Main()
добавил
```
GLCD_Initialize();
GLCD_ClearGraphic();
GLCD_CircleSS(80,80,60,-90,90);
GLCD_ClearText();
GLCD_TextGoTo(7,12);
GLCD_WriteText("5.6 kg/cm2");
```
И дисплей у меня заработал.
Так как подсветки еще нету, то выложу чужие фото
Кратко о составе и функциях данной библиотеки
```
// раздел настройки драйвера
#define SED1335_PORT GPIOA
#define SED1335_A0 GPIO_Pin_10
#define SED1335_WR GPIO_Pin_8
#define SED1335_RD GPIO_Pin_9
#define SED1335_CS GPIO_Pin_11
#define SED1335_RES GPIO_Pin_12
#define SED1335_D0 0
```
```
// команды записи и чтения данных в дисплей
void GLCD_InitPorts(void)
void GLCD_WriteData(unsigned char dataToWrite)
void GLCD_WriteCommand(unsigned char commandToWrite)
unsigned char GLCD_ReadData(void)
unsigned char GLCD_ReadByteFromROMMemory(unsigned char * ptr)
```
Графическая часть и текстовая часть
```
void GLCD_Rectangle(unsigned int x, unsigned int y, unsigned int b, unsigned int a);//Прямоугольник
void GLCD_Circle(unsigned int cx, unsigned int cy ,unsigned int radius); //Окружность
void GLCD_Line(int X1, int Y1,int X2,int Y2); //Линия
void GLCD_SetPixel(unsigned int x,unsigned int y, int color) // установить пиксель в черный или белый цвет
void GLCD_WriteText(char * tekst) // отправка строки в дисплей
void GLCD_WriteTextP(char * tekst), // отправка строки в дисплей
void GLCD_SetCursorAddress(unsigned int address) // Установка курсора
void GLCD_TextGoTo(unsigned char x, unsigned char y) //, Смещение курсора
void GLCD_GraphicGoTo(unsigned int x, unsigned int y) // смещение кисти
void GLCD_ClearText(void), // очистка текста
void GLCD_ClearGraphic(void), // очистка графики
void GLCD_Bitmap(char * bmp, int x, int y, int width, int height) // вывести картинку
```
Спасибо за внимание | https://habr.com/ru/post/233405/ | null | ru | null |
# CKEditor файловый менеджер
В связи с выходом новой версии популярного и весьма функционального WYSIWYG редактора, пришлось сделать небольшой файл менеджер.
Причиной тому послужило отсутствие по умолчанию стандартного файл менеджера, есть конечно CKFinder но он на платной основе.
Поискав разные альтернативы решил потратить время на создание простенького но своего файл менеджера на манер CKFinder'а, что вам и представляю.
Пришлось поискать как интегрировать его с редактором, документации мало, но в конце концов вроде получилось :)
Возможности: Загрузка нескольких файлов, создание папок, транслит закачиваемых файлов, переименование, хотя чего перечислять стандартно всё :)
Общий стиль на манер CKFinder в гамме ACDSee 3
Язык можно изменить в index.html
``> 1. <script type="text/javascript" src="lang/ru.js">script>
>`
**Скриншот**
[](http://demphest.ru/upload/image/ajex-filemanger/ajex-filemanager.jpg "CKEditor File Manager")
**По поводу настроек:**
Подключение в
И непосредственно на странице
``>
> <script type="text/javascript">
> var editor = CKEDITOR.replace('editor1');
> ajexFileManager(editor, '/path/to/ckeditor');
> script>
>`
**Из основных настроек "ajax/cfg.php"**
> `$cfg['url'] = 'upload'; // Папка для загрузок по типам, на манер как раньше было
> $cfg['root'] = $\_SERVER['DOCUMENT\_ROOT'] . DIR\_SEP . $cfg['url'] . DIR\_SEP; // http://www.yousite.com/upload/ абсолютный путь до папки
> $cfg['quickdir'] = ''; // Папка для быстрой загрузки, это закладка Закачать - не открывая файл менеджер, пример: $cfg['quickdir'] = 'quick-folder'; само собой будет по типам, если грузите изображение то оно попадет в /upload/image/quick-folder/filename.jpg
>
>
> $cfg['thumb']['width'] = 150; // ширина создаваемых превьюшек
> $cfg['thumb']['height'] = 120; // высота
> $cfg['thumb']['quality']= 80; // качество сжатия
> $cfg['thumb']['cut'] = true; // дабы превьюшки не вызывали смех они будут резаться, а не пропорционально уменьшаться
> $cfg['thumb']['auto'] = true; // если изображения были закачены через ftp то автоматически превью не создастся, поэтому при включенной данной опции будет проверка на существование превьюшки
> $cfg['thumb']['dir'] = '\_thumb'; // скрытая папка которая будет создаваться там где лежат изображения, думал делать одну для всех, но решил пока так сделать
> $cfg['thumb']['date'] = "j.m.Y, H:i"; // дата в отображении с именами файлов
>
> // ну тут всё понятно, права выставляеме файлам и папкам при создании и загрузке
> $cfg['chmod']['file'] = 0777;
> $cfg['chmod']['folder'] = 0755;`
Сам по себе не тяжелый (собственно несколько текстовых файлов), изображения расширений только объем занимают
**Скачать:**
~~[Только сам файл менеджер (.rar ~335Kb)](http://demphest.ru/?upload/file/ckeditor-filemanager/ajexFileManager.rar)
[Полностью вместе с CKEditor (.rar ~1.1Mb)](http://demphest.ru/?upload/file/ckeditor-filemanager/ckeditor.rar)~~
Файл менеджер делался для себя, но наверняка еще кому-нибудь пригодится. Не лишён глюков и некоторого функционала, всё постепенно со временем сделаю/исправлю, если интерес у сообщества будет :)
Последующие обновления буду публиковать здесь и [у себя на сайте](http://demphest.ru/ru/programming/ckeditor-file-manager/)
**P/S:** Первый пост, ~~кармы нету, поэтому в «web разработка» не могу перенести~~(fixed: спасибо за карму, перенёс), и ~~подсветку синтаксиса для кода не нашёл покамесь как сделать здесь~~(спасибо за совет [krig](https://habrahabr.ru/users/krig/), думал здесь встроенная есть) :)
**upd** [demo](http://demphest.ru/demo/filemanager.html)
**upd**
Исправил пару проблем:
— добавил предварительную проверку на php расширения gd и mbstring
— убрал ограничение на закачку файлов, оказывается стояли только графические файлы, теперь можно любые закачивать
— при переименовании файла не удалялась старая превьюшка, и теперь нельзя переименовывать в файлы без расширения и в недопустимые форматы :)
upd: 0.8.1
— Всё таки решил превьюшки ложить в отдельную папку, чтобы пачки папок не разводить, структура будет аналогичная оригиналу
— Сделал сортировку файлов
— Добавил в дерево размер папки
— Немного изменил структуру папок
— Сделал простенькую проверку на работоспособность, необходимо вызывать php файл напрямую с isWork, пример: [ckeditor/ajexFileManager/ajax/php/ajax.php?isWork](http://demphest.ru/demo/ckeditor/ajexFileManager/ajax/php/ajax.php?isWork)
— Ну и по мелочам исправил и изменил разное :)
upd: 0.8.2
— косметические изменения :)
В архиве файл менеджер и ckeditor + пример подключения
[Скачать Ajex.FileManager 0.8.2 ~740 Kb](http://demphest.ru/?upload/file/ckeditor-filemanager/ajexFileManager.rar)`` | https://habr.com/ru/post/69838/ | null | ru | null |
# Устройство пакетной системы OpenWrt
Операционная система OpenWrt обычно используется как прошивка для роутеров. Типичное применение заключается в том, чтобы установить и забыть. Но если вдруг вам чего-то не хватит, то придётся разбираться в устройстве дистрибутива.
[](https://habr.com/ru/company/ruvds/blog/530984/)
OpenWrt использует opkg в качестве пакетного менеджера, точнее, [собственный форк](https://git.openwrt.org/project/opkg-lede.git). Дебианщикам он во многом покажется знакомым: похожие команды, похожий формат репозитория и пакетов.
Мне захотелось запатчить LUCI (этого в статье не будет), но адекватного быстрого введения я не нашёл, пришлось самостоятельно собирать отрывки сведений из разрозненной документации, статей и примеров, поглядывая в код и на результаты работы. Бонусом собрал примитивный (но бесполезный на практике) пакет, которого ещё нет в репозитории. Собранным ликбезом делюсь ниже.
Устройство репозитория
----------------------
В файловой системе OpenWrt есть файл `/etc/opkg/distfeeds.conf`, в нём указывается системный (предоставленный разработчиками OpenWrt и opkg) список репозиториев. Собственные и сторонние репозитории можно указать в `/etc/opkg/customfeeds.conf`. Формат однострочный, состоит из трёх слов:
1. `src` или `src/gz`, от этого зависит, будет качаться файл `Packages` или `Packages.gz`. Судя по коду, есть другие опции для первого слова, но я не нашёл репозиториев, для которых это было бы актуально. Несмотря на `src` в названии, это репозиторий для бинарных пакетов. Специального формата репозиториев для пакетов с исходным кодом, аналогичного тому, что используется в Debian/APT, у opkg не предусмотрено.
2. Название репозитория или «фида» в терминологии opkg/OpenWrt.
3. URL, внутри которого лежит файл `Packages`/`Packages.gz`.
При выполнении `opkg update` к URL через `/` добавляется `Packages` или `Packages.gz`, список пакетов и подписи сохраняются в `/tmp/opkg-lists`, файл называется соответственно второму слову в списке репозиториев. Отсюда два важных вывода:
1. При перезагрузке кэш очистится. На встроенных системах вроде роутеров это абсолютно разумно.
2. В `/etc/opkg/customfeeds.conf` можно оверрайдить системные фиды своими собственными, дав им такое же название. opkg ругнётся, но проглотит оверрайд, сложив нужный файлик вместо загруженного ранее.
Заодно будет загружен `Packages.sig`, в котором должен лежать хэш распакованного списка пакетов. В самом списке просто перечисляются пакеты, для каждого пакета есть несколько значений, значения для разных пакетов отделяются пустой строкой. Вот самые важные поля для каждого пакета:
* `Package`, имя пакета;
* `Version`, версия, при наличии нескольких пакетов с одинаковым именем можно выбрать версию, по умолчанию установится самая свежая;
* `Depends`, зависимости от других пакетов, пакетный менеджер доустановит перечисленные пакеты в случае их отсутствия в системе;
* `Filename`, путь к файлу относительно базового URL репозитория, обычно репозиторий плоский и всё лежит там же, где и `Packages.gz`;
* `SHA256sum`, заявленный репозиторием хэш пакета.
Если хотите больше подробностей, можете просто прочитать один из таких списков [прямо в браузере](https://downloads.openwrt.org/snapshots/targets/x86/generic/packages/Packages).
Бинарные пакеты
---------------
Бинарные пакеты почти аналогичны пакетам Debian. Разница следующая:
1. Расширении `.ipk` вместо `.deb`.
2. Упаковывается всё с помощью `tar` и сжимается с помощью `gzip`, это же справедливо для вложенных архивов. В Debian архив верхнего уровня упаковывается более примитивным `ar`, а вложенные архивы чаще всего имеют расширение `.tar.xz`, инструменты используются соответствующие.
Если вы поменяете расширение пакета для OpenWrt на `.tar.gz` и распакуете, то обнаружите внутри два архива и один текстовый файл. Файл называется `debian-version`, в нём содержится версия формата бинарного файла и она нам не очень интересна, в современных системах эта версия всегда равняется `2.0`.
Архив `data.tar.gz` содержит исполняемые файлы, файлы конфигурации и всё, ради чего устанавливается пакет. Если распаковать его в корень ФС, вы получите все ожидаемые файлы на нужных местах, в `/usr/bin/`, `/etc/` и так далее.
А в `control.tar.gz` находятся вспомогательные файлы для пакетного менеджера. Это скрипты, которые должны выполняться до или после установки и удаления (`preinst`, `postinst`, `prerm`, `postrm`), сведения о файлах, являющихся конфигурационными, и метаинформация о пакете, во многом повторяющая ту, что содержится в `Packages`.
Система сборки пакетов
----------------------
Сборочная система (она же SDK) выполнена в виде Make-фреймворка. Фреймворк не подразумевает, что вы будете собирать пакеты по отдельности, его основная задача заключается в сборке целых репозиториев.
SDK для `x86_64` лежит в [git](https://git.openwrt.org/openwrt/openwrt.git). Есть [архив](https://downloads.openwrt.org/releases/19.07.4/targets/x86/64/openwrt-sdk-19.07.4-x86-64_gcc-7.5.0_musl.Linux-x86_64.tar.xz) (ссылка скоро устареет, но найти свежий несложно), который сэкономит вам время на компиляции тулчейна для сборки. Внутри особый интерес представляет файл `feeds.conf.default`. Формат несложный, через пробел:
1. Ключевое слово `src-git`. Поддерживается [не только git](https://github.com/openwrt/openwrt/blob/openwrt-19.07/scripts/feeds#L139-L192), но сейчас репозиториев в иных VCS нет.
2. Название фида.
3. URL git-репозитория, в котором можно указать коммит или тег. Если вы знаете, как называется такая спецификация, подскажите, пожалуйста.
Сам репозиторий с пакетами устроен максимально просто: в корне репозитория категория пакета, на втором уровне директория с названием пакета, а внутри него лежит `Makefile`, опционально `Config.in` для дополнительных опций при выполнении `make menuconfig` и субдиректория `patches` с соответствующим содержимым. Для простейшего пакета достаточно только `Makefile`. Для примера можете заглянуть в [зеркало основного репозитория](https://github.com/openwrt/packages/).
Тестовая сборка
---------------
Я попробовал собрать GNU Hello, чтобы проверить, как работает SDK. Это сравнительно монструозный Hello World, написанный в строгом соответствии с гайдлайнами проекта GNU, его единственная задача заключается в иллюстрации этих гайдлайнов. Отдельный репозиторий для него не создавал, а вместо этого «подсунул» в базовые пакеты SDK, откуда и скомпилировал.
Для работы самого SDK в окружениии Debian понадобятся пакеты `libncurses-dev` (для меню сборки), `build-essential` (GCC и прочие стандартные зависимости программ на C), `gawk`, `unzip`, `file`, `rsync` и `python3`. Также для создания репозитория из собранных пакетов, потребуется утилита для генерации ключей `usign`. Её в репозитории нет, поэтому дополнительно потребуется `cmake` для сборки. Этот инструмент можно заменить как на GPG, так и на `signify-openbsd`, но она рекомендуется и разрабатывается проектом OpenWrt, а также гораздо приятней в использовании.
Компилируем и устанавливаем `usign`:
```
git clone https://git.openwrt.org/project/usign.git
cd usign
cmake .
make
sudo make install
```
Вместо установки (`sudo make install`) можете просто запомнить, где находится бинарь, чтобы в дальнейшем дёргать его руками.
Теперь базовая настройка SDK:
```
git clone https://git.openwrt.org/openwrt/openwrt.git
cd openwrt
./scripts/feeds update -a
./scripts/feeds install -a
```
Напоминаю, что вместо клонирования из git, можете скачать и распаковать архив с прекомпилированным тулчейном. Не забудьте только скачать свежую версию!
Выполняя `./scripts/feeds update -a` мы клонируем/обновляем все репозитории из feeds.conf(.default), проверяем зависимости и готовим директорию `staging_dir/host/bin` с исполняемыми файлами (в основном это симлинки на системные утилиты). Следующая команда, `./scripts/feeds install -a`, рассовывает симлинки в `package/feeds`, откуда они и будут браться для компиляции. Эти две команды не обязательны для сборки моего кастомного пакета.
Далее выполняется `make menuconfig`. Можно пропустить, но при компиляции пакета всё равно выдаст соответствующее окошко. В нём достаточно поменять таргет и сабтаргет, чтобы всё скомпилировалось под x86\_64 и выйти, согласившись с сохранением конфига. Также потребуется собрать вспомогательный инструментарий для сборки (`make tools/install`) и тулчейн (`make toolchain/install`). Если вы качали SDK из архива, то `make menuconfig` вам не покажет опций для выбора таргета, а сборка инструментария и тулчейна не требуется — всё уже есть на месте.
Теперь я создаю директорию `package/devel/hello`, в которой размещаю `Makefile` следующего содержания:
**Makefile**
```
include $(TOPDIR)/rules.mk
PKG_NAME:=hello
PKG_VERSION:=2.9
PKG_RELEASE:=1
PKG_LICENSE:=GPL-3.0-or-later
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
PKG_SOURCE_URL:=@GNU/hello/
PKG_HASH:=ecbb7a2214196c57ff9340aa71458e1559abd38f6d8d169666846935df191ea7
include $(INCLUDE_DIR)/package.mk
define Package/hello
SECTION:=devel
CATEGORY:=Development
TITLE:=GNU Hello
URL:=https://www.gnu.org/software/hello/
endef
define Package/hello/description
The GNU Hello program produces a familiar, friendly greeting. Yes,
this is another implementation of the classic program that prints
“Hello, world!” when you run it. However, unlike the minimal version
often seen, GNU Hello processes its argument list to modify its
behavior, supports greetings in many languages, and so on. The primary
purpose of GNU Hello is to demonstrate how to write other programs that
do these things; it serves as a model for GNU coding standards and GNU
maintainer practices.
endef
define Package/hello/install
$(INSTALL_DIR) $(1)/usr/bin
$(INSTALL_BIN) $(PKG_BUILD_DIR)/src/hello $(1)/usr/bin/
endef
$(eval $(call BuildPackage,hello))
```
В основном всё должно быть понятно без пояснений. Подключаются файлы фреймворка, описываются основные параметры пакета, `@GNU` подменяется на зеркала проекта GNU (определены во фреймворке), а путь состоит из двух частей: `PKG_SOURCE_URL`, в котором указывается базовый URL для всех версий и расширяется конкатенацией именем файла из `PKG_SOURCE` через слэш. В `Package/hello/install` содержатся инструкции по сборке бинарей в архив `data.tar.gz`. Дополнительные опции для сборки, если потребуются, доступны в [документации](https://openwrt.org/docs/guide-developer/packages). Кстати, не забудьте, что make очень требователен к отступам, у меня вместо начальных пробелов были одиночные табы.
Снова вызываете `make menuconfig`, проверяете, что в обозначенной секции (Development в моём случае) отмечен пакет hello и выходим сохранив конфиг. Наконец, собираем пакет в три этапа; скачивание, распаковка и собственно компиляция:
```
make package/hello/download
make package/hello/prepare
make package/hello/compile
```
В результате я получил пакет `bin/packages/x86_64/base/hello_2.9-1_x86_64.ipk`. Можно собирать репозиторий. Генерируем пару ключей (`usign -G -c 'openwrt test repo' -s key-build -p key-build.pub`, приватный ключ обязательно должен называться `key-build`), и собираем репозиторий: `make package/index`. На этом этапе сборка может ругнуться на отсутствие `usign` в директории со вспомогательными утилитами, я решил проблему симлинком: `ln -s `which usign` staging_dir/host/bin/usign`. Теперь рядом с пакетом лежит полный набор, необходимый для репозитория.
Проверяем репозиторий вместе с пакетом
--------------------------------------
Вы можете проверить всё на настоящем роутере (не забудьте только выбрать правильный таргет), но я воспользовался Докером. В Докерхабе есть образ OpenWrt для x86\_84, который можно запустив, пробросив внутрь контейнера директорию с SDK: `sudo docker run -it --name openwrt_test -v $PWD:/opt openwrtorg/rootfs`. Потыкайте кнопку ввода пока не появится приглашение Баша.
Копирую ключ из проброшенной директории (`cp /opt/key-build.pub /etc/opkg/keys/usign -F -p /opt/key-build.pub`, название ключа обязательно должно совпадать с идентификатором), добавляю свой локальный репозиторий (`echo src/gz local file:///opt/bin/packages/x86_64/base >> /etc/opkg/customfeeds.conf`), обновляю репозиторий (`opkg update`). Вывод начинается с обнадёживающего текста, всё подписано верно:
```
# opkg update
Downloading file:///opt/bin/packages/x86_64/base/Packages.gz
Updated list of available packages in /var/opkg-lists/local
Downloading file:///opt/bin/packages/x86_64/base/Packages.sig
Signature check passed.
```
Осталось только установить и проверить:
```
root@34af2f6e849b:/# opkg install hello
Installing hello (2.9-1) to root...
Downloading file:///opt/bin/packages/x86_64/base/hello_2.9-1_x86_64.ipk
Configuring hello.
root@34af2f6e849b:/# hello
Hello, world!
```
Ура, готово! Несмотря на разбросанную по статьям документацию, процесс сборки пакетов довольно прост.
[](https://ruvds.com/ru-rub/news/read/126?utm_source=habr&utm_medium=article&utm_campaign=morq&utm_content=ustrostvo_paketnoj_sistemy_openwrt)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=morq&utm_content=ustrostvo_paketnoj_sistemy_openwrt#order) | https://habr.com/ru/post/530984/ | null | ru | null |
# Делаем страницу на React с базой сотрудников при помощи Airtable и Quarkly
Слышали про такой инструмент, как Airtable, но не знали, с чего начать? Тогда приглашаем в мир визуального ~~программирования~~ построения БД!
Этим постом мы начинаем цикл обучающих статей, в которых будем давать практические примеры работы с нашим инструментом Quarkly. В этом уроке мы сделаем простое веб-приложение, которое будет показывать сотрудников компании. При создании приложения ни один сотрудник РЖД не пострадал.
Фронт будем делать при помощи Quarkly, а данные подтягивать из базы в Airtable. На выходе получим react-приложение, синхронизированное с базой данных.
Преамбула. Почему Airtable
--------------------------
Airtable — популярный no-code инструмент, в котором вы можете делать свои базы данных большого объема. Выглядят они как таблицы, но имеют гораздо более мощный функционал. В частности, для нашего урока выбор Airtable обусловлен легким способом передачи данных по API.
Если вы впервые слышите про Airtable, перед началом работы не будет лишним почитать [официальное руководство](https://support.airtable.com/hc/en-us/sections/360009677453) на сайте компании. Также советуем не стесняться и задавать вопросы в чатике [Airtable Chat & Community](https://t.me/airtable_russia) в телеграм.
Фронтендная часть работ будет сделана в Quarkly, и для этого мы будем использовать всего два компонента:
* *Карточка сотрудника*. В ней будут фото, текстовые данные и две кнопки: отправить email и позвонить. Эти данные карточка будет получать от родительского компонента — обертки.
* *Обертка*. Она будет принимать данные из Airtable, генерировать карточки и передавать в них данные.
Для тех, у кого нет времени вникать в пост в печатном формате, мы подготовили видео с субтитрами и таймкодами:
[](https://www.youtube.com/watch?v=mbPukPi0RZA)
Часть 1. Делаем визуал в Quarkly
--------------------------------
#### Создание карточки:
1. Создадим новый проект в Quarkly, назовем его *Airtable Example*;
2. Перейдем внутрь проекта;
3. Добавим готовый блок с карточками сотрудников. Для этого кликаем на черную кнопку + посередине и выбираем блок из категории *Team*;
4. Выбираем на панели слоев первую карточку (*StackItem*) и преобразуем её в компонент;
Для этого нажмите на «троеточие» и выберите пункт *Convert to Component*. Назовем этот компонент *EmployeeCard*.
5. Теперь мы можем свободно редактировать код этого react-компонента, но пока этого делать не будем и перейдем к созданию компонента-обертки.
#### Создание обертки:
1. Подготовим обертку к преобразованию в компонент. Для этого сначала удалим оставшиеся три карточки, они нам не нужны;
2. Теперь вытащим *EmployeeCard* из *Stack*. Затем преобразуем *Stack* в компонент, как мы уже делали ранее с *EmployeeCard*: правая панель, кнопка «троеточие» и *Convert to Component*. Компонент назовем *EmployeeTable*.
На этом пока всё, подготовительный этап завершен. Оставим компоненты и займемся базой в Airtable.
Часть 2. Создаем базу данных в Airtable
---------------------------------------
Переходим на сайт [Airtable](https://airtable.com/) и регистрируемся/авторизуемся.
1. Кликаем на кнопку *Add a base*, чтобы создать новую базу. Из выпадающего меню выберите пункт *Start with a template*;
2. Выбираем категорию *HR & Recruiting* и шаблон *Employee directory*. Далее кликаем на кнопку *Use template*;
3. Переходим в созданный проект;
На данном этапе здесь мы ничего менять не будем, в текущем виде база уже нас устраивает.
Часть 3. Получаем доступ к API
------------------------------
Изначально Airtable интересен для нас именно за счет удобного API. При этом, что немаловажно, возможность забирать данные и отправлять их в нашу базу Airtable предоставляет бесплатно.
1. Переходим на страницу выбора API проектов: <https://airtable.com/api>
2. Выбираем наш проект *Employee directory*. В появившейся документации переходим на раздел *AUTHENTICATION*.
3. Скопируйте две строчки, расположенные ниже заголовка *EXAMPLE USING BEARER TOKEN (RECOMMENDED)*.
У меня они выглядят так:
`$ curl https://api.airtable.com/v0/app2MdLITmRTBsrkg/Employee%20directory \
-H "Authorization: Bearer YOUR_API_KEY"`
4. Теперь нам нужен *YOUR\_API\_KEY*. Это уникальный ключ доступа, который генерируется для каждого аккаунта. Найти его можно в настройках.
5. На открывшейся странице перейдите в раздел API и нажмите на кнопку *Generate API key*;
6. Скопируйте ключ. Сохраните его рядом со строчками из пункта 3. Они пригодятся нам далее.
Часть 4. Интегрируем базу Airtable в Quarkly
--------------------------------------------
На этом этапе мы добавим в компонент *EmployeeTable* код, который будет забирать данные из API.
1. Переходим в редактирование кода компонента. Для этого откроем вкладку *Components* и нажмем на кнопку <> у *EmployeeTable* (она появится при наведении курсора на компонент);
2. Сейчас код компонента выглядит так:
3. Заменим:
```
import React from "react";
```
на:
```
import React, { useEffect, useState } from "react";
```
Таким образом мы импортируем хуки useEffect и useState, которые помогут нам в дальнейшем;
4. Ниже добавляем строчку, чтобы импортировать наш компонент *EmployeeCard*:
```
import EmployeeCard from "./EmployeeCard";
```
5. Заменим *children* (они нам пока не нужны) на *override* (пригодятся, чтобы выбирать элементы и стилизовать их на странице):
```
const EmployeeTable = props => {
const {
children,
rest
} = useOverrides(props, overrides, defaultProps);
```
на:
```
const EmployeeTable = props => {
const {
override,
rest
} = useOverrides(props, overrides, defaultProps);
```
6. Ниже добавим вызов хука *useState*, который будет следить за состоянием:
```
const [employees, setEmployees] = useState([]);
```
7. Далее добавим хук *useEffect*, который будет делать запросы к API Airtable и помещать полученные данные в наше состояние через функцию *setEmployees*.
Добавляем сюда строчки, которые скопировали ранее. В *fetch* мы добавляем URL адрес нашей базы, добавляя параметр *?view=All%20employees*. В *headers* мы добавляем параметры авторизации и непосредственно сам API ключ, который мы сгенерировали в 3 части этой статьи, подпункт 4.
```
useEffect(() => {
fetch("https://api.airtable.com/v0/appWw7KBKSc9bPjZE/Employee%20directory?view=All%20employees", {
headers: {
'Authorization': 'Bearer YOUR_API_KEY'
}
})
.then(response => response.json())
.then(data => setEmployees(data.records.map(({ fields }) => fields)));
}, []);
```
8. Теперь будем генерировать карточки из полученных данных, передавая им *props* с данными и *override*. Он нужен, чтобы выбирать и стилизовать элементы на странице.
Меняем:
```
return
{children}
;
};
```
на:
```
return
{
employees.map(employee => )
}
;
};
```
9. Нажмите Ctrl + S (или Cmd + S на Mac). Окончательный код выглядит так:
```
import React, { useEffect, useState } from "react";
import { useOverrides, Stack } from "@quarkly/components";
import EmployeeCard from "./EmployeeCard";
const defaultProps = {
"margin-top": "40px"
};
const overrides = {};
const EmployeeTable = props => {
const {
override,
rest
} = useOverrides(props, overrides, defaultProps);
const [employees, setEmployees] = useState([]);
useEffect(() => {
fetch("https://api.airtable.com/v0/appWw7KBKSc9bPjZE/Employee%20directory?view=All%20employees", {
headers: {
'Authorization': 'Bearer YOUR_API_KEY'
}
})
.then(response => response.json())
.then(data => setEmployees(data.records.map(({ fields }) => fields)));
}, []);
return
{
employees.map(employee => )
}
;
};
Object.assign(EmployeeTable, {
...Stack,
defaultProps,
overrides
});
export default EmployeeTable;
```
**Важно**: не забудьте вставить свой уникальный API ключ вместо текста *YOUR\_API\_KEY*.
Готово! Теперь мы получаем данные от Airtable, помещаем их в *employees* и проходимся по нему методом *map*. На каждую запись в *employees* мы создаем , в который передаем как пропс конкретные данные.
Осталось научить *EmpolyeeCard* принимать эти данные и показывать их в нужном месте.
Часть 5. Учим EmpolyeeCard работать с БД
----------------------------------------
Здесь мы научим карточку сотрудника принимать данные и показывать их.
1. Откроем код компонента. Для этого заходим во вкладку *Components*, ищем там *EmployeeCard*, наводим курсор и жмем на кнопку <>.
2. Сейчас код компонента выглядит так:
```
import React from "react";
import { useOverrides, Override, StackItem } from "@quarkly/components";
import { Box, Text } from "@quarkly/widgets";
const defaultProps = {
"width": "25%",
"lg-width": "50%",
"sm-width": "100%"
};
const overrides = {
"box": {
"kind": "Box",
"props": {
"height": "0",
"margin": "0 0 20px 0",
"padding-bottom": "100%",
"background": "url(https://images.unsplash.com/photo-1503443207922-dff7d543fd0e?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=582&q=80) 50% 0/cover no-repeat"
}
},
"text": {
"kind": "Text",
"props": {
"color": "--grey",
"margin": "0",
"children": "CEO"
}
},
"text1": {
"kind": "Text",
"props": {
"as": "h3",
"font": "--headline3",
"margin": "5px 0 20px 0",
"children": "Nathan K. Joe"
}
},
"text2": {
"kind": "Text",
"props": {
"as": "p",
"margin": "20px 0 5px 0",
"children": "This space is 100% editable. Use it to introduce a team member, describe their work experience and role within the company. This is also a great place to highlight a team member's strong sides."
}
}
};
const EmployeeCard = props => {
const {
override,
children,
rest
} = useOverrides(props, overrides, defaultProps);
return
{children}
;
};
Object.assign(EmployeeCard, { ...StackItem,
defaultProps,
overrides
});
export default EmployeeCard;
```
3. Ищем строчку:
```
} = useOverrides(props, overrides, defaultProps);
```
и добавляем ниже:
```
const { employee = {} } = rest;
```
В объект *employee* помещаем наши данные.
4. На примере фотографии сотрудника проверим, что всё работает, как нужно. Ищем строку и меняем:
на:
Также ищем:
```
"background": "url(https://images.unsplash.com/photo-1503443207922-dff7d543fd0e?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=582&q=80) 50% 0/cover no-repeat"
```
и меняем на:
```
"background-size": "cover",
"background-position": "center",
"background-image": "url(https://images.unsplash.com/photo-1503443207922-dff7d543fd0e?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=582&q=80) 50% 0/cover no-repeat"
```
Должно получится так:
5. Смотрим, какие поля у нас есть. Документация для API в Airtable сделана очень хорошо. Название полей можно посмотреть в <https://airtable.com/api>, выбрав свою базу.
Далее ищем раздел *EMPLOYEE DIRECTORY TABLE*.
Итак, у нас есть:
*Name
Department
Home address
Email address
DOB
Start date
Phone
Reports to
Title
Status
Photo
Location*
6. Добавим Title. Для этого заменим:
на:
И не забудем отредактировать *overrides* этого компонента, чтобы мы могли его выбирать и редактировать на странице.
Меняем:
```
"text": {
"kind": "Text",
"props": {
"color": "--grey",
"margin": "0",
"children": "CEO"
}
},
```
на:
```
"title": {
"kind": "Text",
"props": {
"color": "--grey",
"margin": "0",
"children": "Title"
}
},
```
Сохраняем и проверяем:
**Результат**: в карточки добавилась строка с профессией.
7. Повторим такие же действия для *Name* и *Home address*.
Заменим:
```
```
на:
```
```
И поправим их *overrides*. Для этого заменим:
```
"text1": {
"kind": "Text",
"props": {
"as": "h3",
"font": "--headline3",
"margin": "5px 0 20px 0",
"children": "Nathan K. Joe"
}
},
"text2": {
"kind": "Text",
"props": {
"as": "p",
"margin": "20px 0 5px 0",
"children": "This space is 100% editable. Use it to introduce a team member, describe their work experience and role within the company. This is also a great place to highlight a team member's strong sides."
}
}
```
на:
```
"name": {
"kind": "Text",
"props": {
"as": "h3",
"font": "--headline3",
"margin": "5px 0 5px 0",
"children": "Name"
}
},
"address": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Home address"
}
},
```
Сохраняем и снова проверяем:
8. Добавим ещё несколько *Text* по аналогии. Для простоты мы не будем брать *Department* и *Reports to*, потому что эти данные находятся в другой базе *DEPARTMENTS TABLE*.
Добавляем:
```
```
и
```
"address": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Home address"
}
},
"Start date": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Start date"
}
},
"Status": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Status"
}
},
"DOB": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Birth date"
}
},
```
Проверяем результат:
9. Теперь добавим два компонента *Link*, в которых у нас будут *Phone* и *Email*:
```
import { Box, Text } from "@quarkly/widgets";
```
меняем на:
```
import { Box, Text, Link } from "@quarkly/widgets";
```
И добавляем следующие строки:
```
```
Не забыв про их *overrides*:
```
"Email address": {
"kind": "Link",
"props": {
"margin": "10px 0 5px 0",
"color": "--primary",
"text-decoration": "none",
"children": "Email"
}
},
"Phone": {
"kind": "Link",
"props": {
"margin": "10px 0 5px 0",
"color": "--primary",
"text-decoration": "none",
"children": "Phone"
}
},
```
Проверяем результат:
Финально наш код выглядит так:
```
import React from "react";
import { useOverrides, Override, StackItem } from "@quarkly/components";
import { Box, Text, Link } from "@quarkly/widgets";
const defaultProps = {
"width": "25%",
"lg-width": "50%",
"sm-width": "100%"
};
const overrides = {
"box": {
"kind": "Box",
"props": {
"height": "0",
"margin": "0 0 20px 0",
"padding-bottom": "100%",
"background-size": "cover",
"background-position": "center",
"background-image": "url(https://images.unsplash.com/photo-1503443207922-dff7d543fd0e?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=582&q=80) 50% 0/cover no-repeat"
}
},
"title": {
"kind": "Text",
"props": {
"color": "--grey",
"margin": "0",
"children": "title"
}
},
"name": {
"kind": "Text",
"props": {
"as": "h3",
"font": "--headline3",
"margin": "5px 0 5px 0",
"children": "Name"
}
},
"address": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Home address"
}
},
"Start date": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Start date"
}
},
"Status": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Status"
}
},
"DOB": {
"kind": "Text",
"props": {
"as": "p",
"margin": "10px 0 5px 0",
"children": "Birth date"
}
},
"Email address": {
"kind": "Link",
"props": {
"margin": "10px 0 5px 0",
"color": "--primary",
"text-decoration": "none",
"children": "Email"
}
},
"Phone": {
"kind": "Link",
"props": {
"margin": "10px 0 5px 0",
"color": "--primary",
"text-decoration": "none",
"children": "Phone"
}
},
};
const EmployeeCard = props => {
const {
override,
children,
rest
} = useOverrides(props, overrides, defaultProps);
const { employee = {} } = rest;
return
{children}
;
};
Object.assign(EmployeeCard, { ...StackItem,
defaultProps,
overrides
});
export default EmployeeCard;
```
Делаем коммит в GitHub и публикуем на Netlify:
Ждем несколько минут и проверяем: <https://keen-varahamihira-c54ae1.netlify.app/>
Для проверки синхронизации меняем данные в базе:
Теперь они появятся в приложении:
В дальнейшем мы можем как угодно стилизовать наши элементы с карточками, не нарушая настроенный импорт из Airtable. Пример можно посмотреть [здесь](https://youtu.be/mbPukPi0RZA?t=489).
Репозиторий на GitHub: <https://github.com/quarkly-dev/Getting-data-from-Airtable-tutorial>
Спасибо за внимание!
Если у вас остались вопросы — не стесняйтесь задавать их в комментариях. В следующем уроке рассмотрим ещё один пример работы с данными, покажем как интерактивно их визуализировать, дав возможность пользователю менять фильтры прямо в приложении. | https://habr.com/ru/post/540094/ | null | ru | null |
# eXpress Persistent Objects и тестирование
Всем доброго времени суток!
Хотел бы рассказать о тех возможностях тестирования, которые появляются при использовании ORM от DevExpress™ — eXpress Persistent Objects™ (XPO) для разработчиков на .NET.
Во первых — абстрагирование от конкретной СУБД.
Во вторых — отсутствие необходимости вообще в какой-нибудь СУБД на начальном этапе разработки и при тестировании.
Начнем со структуры нашей БД.
> `...
>
> using DevExpress.Xpo;
>
>
>
> namespace PrimerDlyaHabr {
>
> public class Person : XPObject {
>
> [Indexed("LastName", Unique = true)]
>
> public string FirstName;
>
> public string LastName;
>
> public Decimal Wage;
>
> [Association]
>
> public Department Department;
>
> public Person(Session session) : base(session) { }
>
> }
>
>
>
> public class Department : XPObject {
>
> [Indexed(Unique = true)]
>
> public string Name;
>
> [Association]
>
> public XPCollection Staff { get { return GetCollection("Staff"); } }
>
> public Department(Session session) : base(session) { }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
У нас имеются два класса (таблицы), представляющие отделы (Department) и работников в них (Person).
Теперь напишем для них немного логики.
> `...
>
> using DevExpress.Xpo;
>
> using DevExpress.Xpo.DB.Exceptions;
>
> using DevExpress.Data.Filtering;
>
> using DevExpress.Xpo.Metadata;
>
>
>
> namespace PrimerDlyaHabr {
>
> class PersonWork {
>
> IDataLayer dataLayer;
>
> //Получаем в конструктор источник данных XPO
>
> public PersonWork(IDataLayer dataLayer) {
>
> this.dataLayer = dataLayer;
>
> UpdateSchema();
>
> }
>
>
>
> //Проверка структуры БД. При необходимости ее генерация.
>
>
>
> void UpdateSchema(){
>
> XPClassInfo[] classInfoList = new XPClassInfo[2];
>
> classInfoList[0] = dataLayer.Dictionary.QueryClassInfo(typeof(Person));
>
> classInfoList[1] = dataLayer.Dictionary.QueryClassInfo(typeof(Department));
>
> dataLayer.UpdateSchema(false, classInfoList);
>
> }
>
>
>
> public void AddDepartment(string name) {
>
> using(UnitOfWork session = new UnitOfWork(dataLayer)) {
>
> Department dep = new Department(session);
>
> dep.Name = name;
>
> dep.Save();
>
> session.CommitChanges();
>
> }
>
> }
>
> public bool RemoveDepartment(string name){
>
> using(UnitOfWork session = new UnitOfWork(dataLayer)){
>
> Department dep = GetDepartment(session, name);
>
> if(dep == null)return false;
>
> session.Delete(dep.Staff);
>
> session.Delete(dep);
>
> session.CommitChanges();
>
> return true;
>
> }
>
> }
>
>
>
> Department GetDepartment(UnitOfWork session, string name) {
>
> return session.FindObject(CriteriaOperator.Parse("Name = ?", name));
>
> }
>
>
>
> public int AddPerson(string firstName, string lastName, Decimal wage, string departmentName) {
>
> using(UnitOfWork session = new UnitOfWork(dataLayer)) {
>
> Department dep = GetDepartment(session, departmentName);
>
> if(dep == null) throw new ArgumentException(string.Format("Department '{0}' not found", departmentName));
>
> Person person = new Person(session);
>
> person.FirstName = firstName;
>
> person.LastName = lastName;
>
> person.Wage = wage;
>
> person.Department = dep;
>
> person.Save();
>
> session.CommitChanges();
>
> return person.Oid;
>
> }
>
> }
>
>
>
> public bool RemovePerson(int oid) {
>
> using(UnitOfWork session = new UnitOfWork(dataLayer)) {
>
> Person person = session.GetObjectByKey(oid);
>
> if(person == null) return false;
>
> session.Delete(person);
>
> session.CommitChanges();
>
> return true;
>
> }
>
> }
>
>
>
> CriteriaOperator GetSummaryCriteria(string departmentName) {
>
> return string.IsNullOrEmpty(departmentName) ? null : CriteriaOperator.Parse("Department.Name = ?", departmentName);
>
> }
>
>
>
> public Decimal CalcWageSummary() {
>
> return CalcDeparmentWageSummary(null);
>
> }
>
> public Decimal CalcDeparmentWageSummary(string name) {
>
> using(UnitOfWork session = new UnitOfWork(dataLayer)) {
>
> return (Decimal)session.Evaluate(CriteriaOperator.Parse("Sum(Wage)"), GetSummaryCriteria(name));
>
> }
>
> }
>
>
>
> public int GetPersonCount() {
>
> return GetDeparmentPersonCount(null);
>
> }
>
>
>
> public int GetDeparmentPersonCount(string name) {
>
> using(UnitOfWork session = new UnitOfWork(dataLayer)) {
>
> return (int)session.Evaluate(CriteriaOperator.Parse("Count()"), GetSummaryCriteria(name));
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь мы имеем класс PersonWork, который выполняет какие-то действия с объекта( добавляет/удаляет отделы/людей, считает сумму зарплат и кол-во сотрудников).
В конструкторе класс получает интерфейс IDataLayer — интерфейс источника данных в XPO.
Для тестирования данного класса будем использовать фрэймворк NUnit.
> `...
>
> using System.Data;
>
> using DevExpress.Xpo;
>
> using DevExpress.Xpo.DB;
>
> using NUnit.Framework;
>
>
>
> namespace PrimerDlyaHabr {
>
> [TestFixture]
>
> public class PersonTests {
>
> PersonWork personWork;
>
>
>
> [SetUp]
>
> public void SetUp() {
>
> //Создаем хранилище данных в памяти
>
> IDataStore dataStore = new InMemoryDataStore(new DataSet(), AutoCreateOption.DatabaseAndSchema);
>
> //Создаем источник данных
>
> IDataLayer dataLayer = new SimpleDataLayer(dataStore);
>
> //Создаем тестируемый класс
>
> personWork = new PersonWork(dataLayer);
>
> }
>
>
>
> [Test]
>
> public void Wage() {
>
> personWork.AddDepartment("Main");
>
> personWork.AddPerson("Vasya", "Pupkin", 100, "Main");
>
> personWork.AddPerson("Petya", "Vasin", 150, "Main");
>
>
>
> personWork.AddDepartment("Additional");
>
> personWork.AddPerson("Kostya", "Kostin", 90, "Additional");
>
> personWork.AddPerson("Katya", "Morozova", 90, "Additional");
>
>
>
> Assert.AreEqual(100 + 150 + 90 + 90, personWork.CalcWageSummary());
>
> Assert.AreEqual(100 + 150, personWork.CalcDeparmentWageSummary("Main"));
>
> Assert.AreEqual(90 + 90, personWork.CalcDeparmentWageSummary("Additional"));
>
> Assert.AreEqual(4, personWork.GetPersonCount());
>
> Assert.AreEqual(2, personWork.GetDeparmentPersonCount("Main"));
>
> Assert.AreEqual(2, personWork.GetDeparmentPersonCount("Additional"));
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На выходе получили один класс тестов с одним тестом. Для запуска теста нам не нужно иметь в наличии какой-либо СУБД.
Для этих целей существует класс InMemoryDataStore, который является хранилищем данных в памяти и использует в своих недрах DataSet.
Соответственно этот DataSet можно пользовать для сохранения информации из хранилища в XML'ку.
Наш тест добавляет два отдела, четырех сотрудников и проверяет работу методов подсчета суммы зарплат и кол-ва сотрудников.
Тесты прошли удачно… Система готова…
Теперь нам нужно использовать ее в реальных условиях.
Для этого добавим форму и в ее конструкторе создадим экземпляр personWork.
> `...
>
> using DevExpress.Xpo.DB;
>
> using DevExpress.Xpo;
>
> ...
>
> PersonWork personWork;
>
> public Form1() {
>
> InitializeComponent();
>
> //Получаем строку подключения для MSSql Server
>
> string connectionString = MSSqlConnectionProvider.GetConnectionString("Server", "Database");
>
> //Получаем провайдер подключения к MSSql Server
>
> IDataStore provider = XpoDefault.GetConnectionProvider(connectionString, AutoCreateOption.DatabaseAndSchema);
>
> //Создаем источник данных
>
> IDataLayer dataLayer = new SimpleDataLayer(provider);
>
> //Создаем наш класс работы с персоналом
>
> personWork = new PersonWork(dataLayer);
>
> }
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
//И используем класс по назначению…
Т.е. мы получили готовый класс бизнес-логики, не задумываясь на тем, на какой СУБД он будет работать…
The End. | https://habr.com/ru/post/74009/ | null | ru | null |
# Настройка IPv6 или IPv6 в массы
UPDATE: Так как все это писалось давно, то смысл использовать скрипты сильно теряется, осталось ради истории.
Все можно и наверно лучше настроить через inadyn.
Синтаксис файла конфигурации примерно такой:
dyndns\_system ipv6tb@he.net
username es1125cc87b23bfe1f3ba8923ca7f2ee
password PASS-WORD
alias 10220
На Habrahabr уже существуют статьи по настройке IPv6, например [тут](http://habrahabr.ru/blogs/sysadm/82397/) и [тут](http://habrahabr.ru/blogs/sysadm/82397/). и [тут](http://habrahabr.ru/blogs/p2p/53625/)
Сам я рекомендую почитать [version6](http://version6.ru/why), там примеры зачем это надо.
Я же решил сделать процесс поднятие туннеля более универсальным и автоматизированным…
Для этого я написал два простых скрипта, но ..., давайте по порядку.
В качестве туннельного брокера я использую [Hurricane Electric](http://www.tunnelbroker.com).
[Hurricane Electric](http://www.tunnelbroker.com) позволяет, создавать до 5 туннелей и
умеет автоматически генерировать готовые примеры команд, для поднятие туннеля на разных ОС
Позволяет по URL обновить ваш IPv4 адрес. ([пример](https://ipv4.tunnelbroker.net/ipv4_end.php))
Имеет свой ДНС сервер.
Если бы у меня был прямой статический ip, я бы наверно не стал писать скрипты, а просто поднял бы интерфейсы и радовался.
Но увы, как и у большинства людей у меня прямой динамический ip и нет возможности купить прямой статический (провайдер их не продает), а значит возникает еще две задачи.
1) При замене IPv4, надо будет обновить IPv4 и на конце поднятого туннеля
2) При замене IPv4, надо сообщить брокеру, о его изменении.
ну и еще одна задача, сделать поднятие туннеля и обновление в случае изменения IPv4 универсальным для разных linux систем, а то различные конфигурации сетевых настроек в разных системах — меня утомляют.
Комментарии в скрипте я оставил специально на ENG.
Первый скрипт создает или удаляет туннель IPv6. (используется команды start/stop)
Информацию для заполнения переменных, можно получить после создания туннеля у брокера [на вашей странице](http://ipv4.tunnelbroker.net/main.php).
-----------------Описание-переменных-для-ipv6tunnel----------------------------------------------------------
#Name Tunnel — Имя вашего туннеля. Может быть любым.
HE\_IPv6=«he-ipv6»
#Server IPv4 address: — IP-адрес туннельного сервера.
IPV4\_S=«216.66.80.90»
#Client IPv6 address: — IPv6-адрес вашего конца туннеля.
IPV6\_C=«2001:470:aaaa:ccc::2/64»
#Интерфейс с прямым ip
INT\_WAN=«ppp0»
-----------------начало-скрипта-ipv6tunnel------------------------------------------------------------------------
````
#!/bin/bash
# Create 6in4 tunnel endpoint script
# for use with http://www.tunnelbroker.com (Hurricane Electric)
# C 2010 icCE aka TuLiss (tuliss@gmail.com)
# Distributed under the terms of the GNU General Public License v3
#Name Tunnel
HE_IPv6="he-ipv6"
#Server IPv4 address:
IPV4_S=""
#Client IPv6 address:
IPV6_C=""
#Interface Wan
INT_WAN="ppp0"
#Tunel ttl
TUN_TTL="255"
DESC="6in4"
#WAN IP
WAN_IP=$(ip addr show $INT_WAN | awk '/inet/ {print $2}')
case "$1" in
start)
echo "Starting $DESC tunnel"
ifconfig $HE_IPv6 &>/dev/null
if [ $? -eq 0 ]; then
echo "Tunnel $HE_IPv6 already exists"
exit 1
fi
ip tunnel add $HE_IPv6 mode sit remote $IPV4_S local $WAN_IP ttl $TUN_TTL
ip link set $HE_IPv6 up
ip addr add $IPV6_C dev $HE_IPv6
ip route add ::/0 dev $HE_IPv6
;;
stop)
echo "Stopping $DESC tunnel"
ifconfig $HE_IPv6 &>/dev/null
if [ $? -ne 0 ]; then
echo "Tunnel $HE_IPv6 does not exist"
exit 1
fi
ip link set $HE_IPv6 down
ip tunnel del $HE_IPv6
;;
*)
echo "Usage: $0 {start|stop}" >&2
exit 1
esac
exit 0
````
-----------------конец-скрипта-ipv6tunnel------------------------------------------------------------------------
Второй скрипт, который позволяет передать новый IPv4 адрес брокеру и обновить его на конце вашего туннеля.
-----------------Описание-переменных-для-ipv6update----------------------------------------------------------
IPV4ADDR — так как у нас динамический ip, то оставляем AUTO
MD5PASS — ваш пароль, который используется при входе [на вашу страницу](http://ipv4.tunnelbroker.net/main.php) брокера в виде md5.
Для преобразования пароля в md5 выполните команду:
echo -n 'yourpassword' | md5sum, полученное значение и будет ваш пароль в md5.
USERID — ID пользователя, не путайте его с логином пользователя для входа на сайт брокера. ID представляет из себя длинную последовательность цифр и букв, посмотреть его можно на странице , сразу после
GTUNID — ID туннеля, указан на странице настройки туннеля в поле «Global Tunnel ID»
INT\_WAN — Интерфейс с прямым ip.
#Name Tunnel — Имя вашего туннеля. Может быть любым. Должно совпадать с именем в первом скрипте.
HE\_IPv6=«he-ipv6»
-----------------начало-скрипта-ipv6update-----------------------------------------------------------------------
````
#!/bin/bash
# 6in4 tunnel endpoint update script
# for use with http://www.tunnelbroker.com (Hurricane Electric)
# C 2010 icCE aka TuLiss (tuliss@gmail.com)
# Distributed under the terms of the GNU General Public License v3
#IPV4ADDR WHERE:
# * set ipv4b='AUTO' if you want to set the variable to the requesting client's IP address.
# * set ipv4b='your_public_ipv4_address' if you want to manully provide the address.
IPV4ADDR="AUTO"
#The MD5 Hash of your password
# * Try echo -n 'yourpassword' | md5sum if you need to produce the MD5 Hash of your password
MD5PASS=""
#The UserID from the main page of the tunnelbroker (not your username)
USERID=""
#The Global Tunnel ID from the tunnel_details page
GTUNID=""
#Name IPV6 tunnel
HE_IPv6="he-ipv6"
#Interface Wan
INT_WAN="ppp0"
WAN_IP=$(ip addr show $INT_WAN | awk '/inet/ {print $2}')
output=$(curl -ksSm30 "https://ipv4.tunnelbroker.net/ipv4_end.php?ipv4b=$IPV4ADDR&pass=$MD5PASS&user_id=$USERID&tunnel_id=$GTUNID")
if [ "$output" == "That IPv4 endpoint is already in use." ]; then
echo "That IPv4 endpoint is already in use. $WAN_IP"
elif [ "$output" == "Your tunnel endpoint has been updated to: $WAN_IP" ]; then
ip tunnel change $HE_IPv6 local $WAN_IP
echo "$output"
else
echo "Houston, We've Got a Problem!"
fi
````
-----------------конец-скрипта-ipv6update-----------------------------------------------------------------------
Сохраняем скрипты и делаем их исполняемыми.
Запускаем первый скрипт:
# ./ipv6tunnel start
Если все хорошо, то увидим:
Starting 6in4 tunnel.
ifconfig смотрим появился ли he-ipv6 туннель.
he-ipv6 Link encap:IPv6-in-IPv4
inet6 addr: fe80::xxxx:yyyy/128 Диапазон: Ссылка
inet6 addr: 2001:470:aaaa:ccc::2/64 Диапазон: Общий
Теперь обновим IPv4, выполнив второй скрипт
# ./ipv6update
Your tunnel endpoint has been updated to: ваш\_IP
Если IPv4 не изменился то получим:
That IPv4 endpoint is already in use. ваш\_IP
Пробуем сделать пинг.
ping6 ipv6.google.com или ping6 freebsd.org
Должен получится ответ:
PING ipv6.google.com(2a00:1450:8001::63) 56 data bytes
64 bytes from 2a00:1450:8001::63: icmp\_seq=1 ttl=55 time=74.2 ms
64 bytes from 2a00:1450:8001::63: icmp\_seq=2 ttl=55 time=73.1 ms
Теперь скрипт ipv6tunnel можно добавить в загрузку, а ipv6update ставить в cron и радоваться.
От себя скажу, что правильнее всего, написать скрипт который будет мониторить изменения ip адреса и запускать ipv6update.
>>>>>>>>>>>>>>>>>>>>Bonus<<<<<<<<<<<<<<<<<<<<
Раздача IPv6 в локальную сеть.
По умолчанию, туннельный брокер Hurricane Electric предоставляет нам две подсети с маской /64: одна используется для связи между вашим роутером и туннельным сервером брокера, а вторая (с адресом, отличающимся на единичку в середине, он выделены жирным цветом) предназначена для использования компьютерами в вашей локальной сети, и называется в веб-интерфейсе «Routed /64».
Ради простоты примеров, предположим, что вашей Routed-подсетью оказалась 2001:470:aaab:ccc::/64, а интерфейсом, к которому подключена локальная сеть, является eth1. Так же учтем, что файрвол выключен.
Включаем маршрутизацию IPv6, для этого в /etc/sysctl.conf находим,
net.ipv6.conf.all.forwarding=1
net.ipv6.conf.default.forwarding=1
если их нет то прописываем руками.
Далее загрузим настройки sysctl из файла /etc/sysctl.conf
# sysctl -p
IPv6-адрес из раздаваемой в локалку подсети необходимо также назначить и сетевому интерфейсу самого роутера. Адрес можно выбрать любой, к примеру для роутеров часто используется адрес с ::1. Не перепутайте выданный сегмент для локальной сети, с сегментом для связи тунеля и брокера.
ip addr add 2001:470:aaab:ccc::1/64 dev eth1
Теперь настроем клиентский компьютер.
Добавим к интерфейсу eth0 IPv6, пусть он будет ::2
ip addr add 2001:470:aaab:ccc::2/64 dev eth0
Добавим маршрут по умолчанию, для IPv6 сети.
ip -6 ro add ::/0 via 2001:470:aaab:ccc::1 dev eth0
Пробуем сделать пинг шлюза, а потом какого либо сервиса в интернете.
Посмотреть таблицу роутинга IPv6 можно так:
route -A inet6 -n или ip -6 ro sh
Для Windows 7 достаточно будет указать адреса в параметрах сетевого соединения <Протокол Интернета версия 6>
Так же можно проверить работу IPv6 посетив сайт [HART](http://www.hart.co.jp/ipv6/ipv6check.php)
Для упращение процедуры выдачи IPv6 в локальной сети, можно использовать radvd или dhcpv6.
В Интернете достаточно материала по их настройки.
Если у вас есть вопросы, вы можете задать их на канале [#ipv6-ru](http://webchat.freenode.net/?channels=ipv6-ru) (Жмите, дополнительных клиентов не надо ставить)
Отдельное спасибо все на канале [#gentoo-ru](http://webchat.freenode.net/?channels=gentoo-ru) | https://habr.com/ru/post/85777/ | null | ru | null |
# Eval или include?
Один из текущих проектов разрабатываю на собственном фреймворке, параллельно его обкатывая и дописывая. Зачем мне понадобилось изобретать велосипед, и чем он отличается от существующих, напишу когда буду представлять его общественности. Сейчас же хочется поделиться некоторыми мыслями по поводу производительности и заодно выслушать мнения коллег. Возможно, мои наблюдения будут полезны и тем, кто не использует фреймфорки.
Когда пришлось реализовывать дерево комментариев, столкнулся с необходимостью рекурсивного вызова представления (view в MVC). Так как представления у меня, да и практически везде, — это обычные файлы с кусками HTML-кода и возможностью вставки PHP, то подключаются они с помощью include. Мне стало не по себе, когда представил как этот include вызывается рекурсивно сотни раз. Первая мысль — засунуть файл представления при первом запросе в память и потом выполнять его через eval. Такой подход позволит кешировать код представлений, и даже хранить его в БД. Так как eval кушает только PHP, а представления у нас чистым PHP-кодом не являются, то обрамляем содержимое в '?>' и 'php'.<br/
Итак, за дело.
Тесты
-----
Для начала, разными способами в цикле выведем простенькое представление 'view.php', содержащее, например: `i==$i?`
| | |
| --- | --- |
| **Код** | **Время**, с
(в скобках — с eAccelerator) |
|
```
for($i=0; $i<100; $i++) include ('view.php');
```
| 0,0058141 (0,002068) |
|
```
for($i=0; $i<100; $i++){
$code=' ?>'.file_get_contents('view.php').'php ';
eval($code);
}</pre
```
| 0,005527 (0,0056472) |
|
```
$code=' ?>'.file_get_contents('view.php').'php ';
for($i=0; $i<100; $i++){
eval($code);
}</pre
```
| 0,0015929 (0,0016122) |
И рекурсивно
| | |
| --- | --- |
| **Код** | **Время**, с
(в скобках — с eAccelerator) |
|
```
$i=0;
include('view.php');
---------- view.php ----------
html
php
if(++$i<100){
include('view.php');
}
?
```
| 0,006865 (0,0019491) |
|
```
$i=0;
$code=' ?>'.file_get_contents('view.php').'php ';
eval($code);
---------- view.php ----------
html
<?php
if(++$i<100){
$code=' ?'.file_get_contents('view.php').'php ';
eval($code);
}
?
```
| 0,008599 (0,0087898) |
|
```
$i=0;
$code=' ?>'.file_get_contents('view.php').'php ';
eval($code);
---------- view.php ----------
html
<?php
if(++$i<100){
eval($code);
}
?
```
| 0,0034332 (0,0032461) |
Выводы
------
Первое, что бросается в глаза — варианты с eval не поддаются оптимизации и кешированию с помошью eAccelerator. Поэтому, если вы его используете и вам не нужны другие преимущества eval — лучше остановитесь на include.
Использование eval имеет смысл там, где представления вызываются многократно, но нет возможности использовать акселераторы. Или если представления хранятся в БД.
Немного отличается и обработка ошибок в eval. При возникновении ошибки разбора кода, например, выполнение скрипта не прерывается. Это может быть полезно в некоторых случаях. Но при этом, сообщение об ошибке выглядит по другому, что может немного сбить с толку:
`Parse error: syntax error, unexpected T_ECHO, expecting ')' in /www/test/eval_vs_include/test.php(39) : eval()'d code on line 4`
Здесь указанная ошибка возникла в 4 строке файла view.php, который был скормлен в eval, расположенный в 39 строке файла test.php. Конечно, нам ничего не мешает выводить и название подключаемого файла, если eval возвратил false. Учитывая, что работа над ошибками — это не штатный режим, и на рабочем проекте ошибки не выводятся, считаю указанный недостаток не существенным.
### Eval
+ Быстрее чем include, если не используются акселераторы
+ Возможность кеширования кода представлений во фреймворке или шаблонизаторе
+ Возможность хранения представлений в БД
+ Выполнение скрипта не прерывается при возникновении ошибок
— Не оптимизируется и не кешируется внешними акселераторами
— Вывод ошибок отличаться от привычного
— На некоторых хостингах может быть запрещено выполнение eval
### Include
+ Работает везде
+ Внешние акселераторы на много увеличивают производительность
— Низкая скорость без акселераторов
— Нет возможности кешировать подключаемый из файла код в своём движке
— Подключаемый код может находиться только в файле
Следует отметить, что во фреймворке CodeIgniter eval тоже используется для вывода представлений, но только в том случае, если в настройках указана необходимость замены коротких '=' на '<?php есho' и при этом в настройках PHP короткие теги будут отключены. Во всех остальных случаях используется include. В CakePHP всегда используется include.</div | https://habr.com/ru/post/24038/ | null | ru | null |
# Лучший технический вопрос, который мне задавали на собеседовании
Много воды утекло с тех пор, как я в последний раз участвовал в собеседовании по программированию как соискатель. Но до сих пор помню особенно полюбившийся мне вопрос с такого собеседования. Дело было в MemSQL, году так в 2013. (Они [даже успели переименоваться](https://www.singlestore.com/blog/revolution/), поэтому, полагаю, конкретно этот вопрос они на собеседовании уже не задают. Не чувствую вины за то, что выдаю его. Это отличная история, которая также кажется мне поучительной; просто раньше я о ней никогда не писал).
Окей, вообще, это даже не вопрос как таковой, это программерская задачка на засыпку. Не помню, сколько времени мне на нее дали. Скажем, три часа, считая время, потребовавшееся на постановку задачи.
Поскольку компания MemSQL разрабатывала базу данных, этот челлендж из той же оперы.
Знакомство с memcached
----------------------
Знаете, что такое `memcached`? Нет? Ну, это же хранилище ключей и значений, действующее в оперативной памяти. ([Вот их страничка.](https://memcached.org/about)) Давайте скачаем код этой базы данных и соберем ее – покажу вам, что она умеет делать.
*Возможно, вам понадобится*`brew install libevent`*и, может быть, еще какое-нибудь хозяйство, чтобы успешно собрать memcached. Определиться с этим будет несложно, но, в любом случае, обустройство среды разработки не входило в задачу. Можете предположить, что собеседующие уже дали вам доступ к машине под Linux, в которой уже прописаны все нужные зависимости.*
Чтобы впечатление было аутентичным, как в 2013 году, давайте обойдемся без [репозитория на Github](https://github.com/memcached/memcached) и распакуем из архива tar современные исходники дистрибутива:
```
curl -O https://memcached.org/files/memcached-1.4.15.tar.gz
tar zxvf memcached-1.4.15.tar.gz
cd memcached-1.4.15
./configure
make
```
Вот мы и собрали исполняемый экземпляр `memcached`. Давайте его запустим:
```
./memcached
```
Можем пообщаться с сервером через порт memcached, заданный по умолчанию, это порт 11211. В сущности, его протокол – обычный текст, поэтому для обмена информацией нам подойдет старый добрый `telnet`. (Если у вас уже нет `telnet` в наличии, замените включения `telnet` на `nc -c`)
```
$ telnet 127.0.0.1 11211
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
```
Играем с memcached
------------------
memcached – это хранилище ключей и значений. Таким образом, мы можем приказать ему что-либо запомнить (в виде ассоциации между ключом и значением), а затем снова спросить этот ключ – и система ответит нам, какое значение она по этому ключу запомнила. В memcached все ключи являются строками в формате ASCII, а значения – это всегда произвольные потоки байт (то есть, их длину вам придется указывать вручную). Например, введите в вашем сеансе telnet следующее:
```
set fullname 0 3600 10
John Smith
```
Так вы приказываете memcached запомнить ассоциацию между строковым ключом `fullname` и 10-байтным значением `John Smith`. Другие числа в этой строчке – это значение «флаги» (`0`), запоминаемое вместе со значением потока байт, а также период до устаревания (`3600`) в секундах, по истечении которого memcached забудет эту ассоциацию. В любом случае, как только вы введете две эти строчки, memcached ответит:
```
STORED
```
Теперь можно извлечь значение `fullname`, введя в тот же самый сеанс telnet:
```
get fullname
```
memcached ответит:
```
VALUE fullname 0 10
John Smith
END
```
Можно перезаписать значение, ассоциированное с `fullname`, выдав еще одну команду `set fullname`. Также можно запросить memcached модифицировать значение тем или иным образом; например, есть специальные выделенные команды для операций `append` и `prepend`.
```
append fullname 0 3600 6
-Jones
STORED
get fullname
VALUE fullname 0 16
John Smith-Jones
END
```
Разумеется, если бы вы хотели прикрепить `-Jones` к `fullname`, сделав это из клиентской программы, то *могли бы* поступить примерно так:
```
# pip install python-memcached
import memcache
mc = memcache.Client(['127.0.0.1:11211'])
v = mc.get('fullname') # получить старое значение memcached
v += '-Jones' # прикрепить -Jones
mc.set('fullname', v) # установить новое значение в memcached
```
Но преимущество выделенной команды `append`, применяемой в memcached – в том, что она гарантированно будет выполняться *атомарно*. Если у вас множество клиентов подключено к одному и тому же серверу memcached, и все они одновременно пытаются прикрепить один и тот же ключ, то из-за версии `get/set` некоторые из этих обновлений могут быть потеряны, тогда как с `append` вы можете быть уверены, что все они окажутся учтены.
Еще одна выделенная команда, выполняемая атомарно – это `incr`:
```
set age 0 3600 2
37
STORED
incr age 1
```
memcached реагирует на значение, полученное после инкремента:
```
38
```
Этот отклик полезен именно в силу того, что у нас много клиентов. Если бы вы выдали отдельную команду `get age`, то могли бы увидеть новое значение только после того, как несколько клиентов проведут у себя обновления. Если вы собираетесь использовать такое значение в качестве серийного номера либо в качестве первичного ключа SQL или другим подобным образом, то вам бы очень пригодилась возможность просматривать приращаемое значение *атомарно*.
memcached, конечно же, тоже запоминает приращаемое значение:
```
get age
VALUE age 0 2
38
END
```
Обратите внимание: `37` и `38` у нас по-прежнему сохраняются и возвращаются в виде байтовых строк; они декодируются из ASCII в целые числа и обратно в рамках атомарной операции. Если вы попытаетесь `incr` нецелочисленное значение, то получите ошибку:
```
incr fullname 1
CLIENT_ERROR cannot increment or decrement non-numeric value
```
Наконец, отметим, что `incr` – это полноценная операция сложения: можно сделать инкремент (или декремент, `decr`) на любое положительное значение, а не только на `1`.
```
incr age 10
48
decr age 10
38
incr age -1
CLIENT_ERROR invalid numeric delta argument
```
Кстати, когда закончите разговоры с memcached и захотите разорвать соединение, можете ввести в memcached команду `quit`. (Если вы работаете с `nc -c`, то Ctrl+D тоже подойдет. Либо просто перейдите в консоль, где работает сервер `memcached`, и нажмите Ctrl+C, чтобы его положить.)
Задача: изменить memcached
--------------------------
При помощи команд `incr` и `decr` memcached предоставляет встроенный способ, чтобы атомарно прибавить k к числу. Но другие арифметические операции таким способом не предоставляются, в частности, нет «атомарной операции умножения на k».
Вот вам задача на программирование: добавьте команду `mult` в memcached.
Когда вы закончите, я должен быть в состоянии обратиться по telnet к вашему клиенту memcached и запускать на нем команды вида:
```
mult age 10
380
```
У вас три часа. Поехали!
Анализ
------
Для технического собеседования эта задача просто отличная, так как она позволяет четко разделить весь пул соискателей на три различных типа:
Тип 0 просто оцепенеет от такого челленджа: ведь, решая задачу, придется взаимодействовать с реальной базой кода. Не думаю, что вообще найдется много людей из такой категории, которые вообще дойдут до данного этапа собеседования. Но, если вы обнаружите среди соискателей человека, относящегося к этой категории, то, конечно же, не нанимайте его.
*Кстати, MemSQL по состоянию на 2013 год оперировала чрезвычайно таинственным и высокопроизводительным C++11, поэтому был плюсом (а не минусом) тот факт, что эта задача требует бегло владеть C. Если у вас вся база кода написана на Python и Go, то вы, вероятно, не станете использовать memcached в задачах для собеседования.*
Тип 1 рассмотрит проблему и скажет: “Ах! Конечно же, понятно, как это сделать. Умножение – это просто многократное сложение, а у нас уже есть готовая субпроцедура для сложения, в виде `incr`. От нее и будем плясать. Да, но не станем добавлять константу к значению `x`, а будем складывать значение `x` с самим собой… и вся эта штука должна быть атомарной. Посмотрим-ка, как тут работает блокировка….” Так все три часа окажутся потрачены на все более и более глубокое зарывание в разные кроличьи норы – и ничего работоспособного такой соискатель вам все равно не выдаст. Соискателей из этой группы мы также на работу не берем.
Тип 2 рассмотрит задачу и скажет: «Ах! Ну тут же все понятно! Умножение – все равно, что сложение, только там, где при сложении `+`, я должен поставить `*`». Поэтому он берется за копипаст, меняет все `+` на `*` - и справляется за полтора часа. У кандидатов из этой группы весьма высоки шансы получить оффер.
Наилучшие соискатели заметят, что времени у них остается еще много, поэтому отполируют свою работу – например, убедятся, что форматирование везде единообразное, добавят модульные тесты или уточнят свои «дизайнерские решения», чтобы быть уверенными, что смогут обоснованно ответить на вопрос: «а почему вы так сделали»?
Пошаговый разбор
----------------
Чтобы убедиться, что мои оценки времени на решение задачи – верного порядка, вчера вечером я выполнил всю эту задачу сам.
*Вероятно, этот раздел задолбает всех, кроме самых мазохистов, поэтому если вы не из таких – смело переходите к*[*Заключению*](https://quuxplusone.github.io/blog/2022/01/07/memcached-interview-solution/#conclusion)*.*
Для начала я загнал в grep строку `"incr"` (в кавычках), поскольку мы хотим сымитировать существующую команду `incr`, и ее нужно *где-то* распарсить. Это привело меня к части функции `process_command`, которая выглядит так:
```
} else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "incr") == 0)) {
process_arithmetic_command(c, tokens, ntokens, 1);
} else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "decr") == 0)) {
process_arithmetic_command(c, tokens, ntokens, 0);
```
Аргумент со значением `0` или `1` соответствует параметру `bool incr`. Я изменил его на `int opcode`, а вызывающие стороны изменил так:
```
} else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "incr") == 0)) {
process_arithmetic_command(c, tokens, ntokens, 1);
} else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "decr") == 0)) {
process_arithmetic_command(c, tokens, ntokens, 0);
} else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "mult") == 0)) {
process_arithmetic_command(c, tokens, ntokens, 2);
```
(С точки зрения проектирования такие волшебные числа – весьма плохое решение, но зато оно быстрое и позволяет мне быстро продвигаться вперед. Через десять минут мне в голову придет решение получше, поэтому я пересмотрю этот код).
Пролистаю тело `process_arithmetic_command`, там я буду искать ссылки на инкремент и декремент. Сообщение об ошибке `"CLIENT_ERROR cannot increment or decrement non-numeric value"` кажется несколько неоптимальным, поэтому изменю этот код на
```
if (opcode == 2) {
out_string(c, "CLIENT_ERROR cannot multiply non-numeric value");
} else {
out_string(c, "CLIENT_ERROR cannot increment or decrement non-numeric value");
}
```
И схожим образом – чуть ниже:
```
+if (opcode == 2) {
+ c->thread->stats.mult_misses++;
+} else if (opcode == 1) {
-if (incr) {
c->thread->stats.incr_misses++;
} else {
c->thread->stats.decr_misses++;
}
```
Отметил в голове, что нужно добавить поле `mult_misses` к любым `c->thread->stats`; но пока рвемся вперед. Если о чем-то забуду – то компилятор напомнит мне об ошибке.
```
-switch(add_delta(c, key, nkey, incr, delta, temp, NULL)) {
+switch(add_delta(c, key, nkey, opcode, delta, temp, NULL)) {
```
При помощи Grep вновь спускаемся до `add_delta`.
```
enum delta_result_type do_add_delta(conn *c, const char *key, const size_t nkey,
- const bool incr, const int64_t delta,
+ const int opcode, const int64_t delta,
char *buf, uint64_t *cas,
const uint32_t hv) {
```
Эта сигнатура нарушает мою [ориентировку по const-корректному коду](https://quuxplusone.github.io/blog/2019/01/03/const-is-a-contract/#guidelines-for-reliably-const-correct-code) в том, что передает массу вещей «по const-значению», но нас так просто не проведешь. Заменим `bool` на `int` и движемся дальше.
Наконец, находим искомое место – то, где нужно заменить `+` на `*`! Этот путь в коде принимает вид:
```
+if (opcode == 2) {
+ value *= delta;
+ MEMCACHED_COMMAND_MULT(c->sfd, ITEM_key(it), it->nkey, value);
+} else if (opcode == 1) {
-if (incr) {
value += delta;
MEMCACHED_COMMAND_INCR(c->sfd, ITEM_key(it), it->nkey, value);
} else {
if(delta > value) {
value = 0;
} else {
value -= delta;
}
MEMCACHED_COMMAND_DECR(c->sfd, ITEM_key(it), it->nkey, value);
}
```
Отметим, что нужно реализовать `MEMCACHED_COMMAND_MULT`, едем дальше. Чуть ниже отметим, что для `slab_stats` требуется поле `mult_hits`.
Вот мы и дошли до конца `do_add_delta`. Подождите, это же `do_add_delta`… а что такое `add_delta`? Ах, так она вызывается из двух мест. И в первом из них `bool incr` устанавливается `c->cmd == PROTOCOL_BINARY_CMD_INCREMENT`. Поискав через Grep `PROTOCOL_BINARY_CMD_INCREMENT` выясняем, что здесь в `protocol_binary.h` есть перечисление всех команд! Следует им воспользоваться. Добавим к этому перечислению `PROTOCOL_BINARY_CMD_MULTIPLY` и отрефакторим всю ранее сделанную работу так, чтобы использовалось `PROTOCOL_BINARY_CMD_{DECREMENT,INCREMENT,MULTIPLY}`, а не волшебные числа `0,1,2`. `int opcode` можно оставить в виде `int`, поскольку, если поискать при помощи grep имя перечисляемого типа (`protocol_binary_command`) – убедимся, что практически нигде в базе кода этот тип не используется по имени.
Реализовав `MEMCACHED_COMMAND_MULT` в `trace.h`, также обнаруживаю, что мне понадобится макрос `MEMCACHED_COMMAND_MULT_ENABLED`. Где он используется? Нигде. Окей. Все равно его добавим. ([Забор Честертона](https://www.chesterton.org/taking-a-fence-down/): если я не знаю, для чего существуют эти макросы `_ENABLED`, то я определенно не должен пытаться сделать что-нибудь новаторское с тем новым `_ENABLED`, что окажется у меня. Не буду отрываться от коллектива.)
Разобравшись с оставшимися ошибками компилятора, добавлю поле `mult_hits` в `struct slab_stats`, сразу за `incr_hits` и `decr_hits`. Команда `git grep incr_hits` показывает, что он используется во множестве мест; когда закончу с ним, `git grep mult_hits` покажет такое же количество включений. Строчка
```
out->incr_hits += stats->slab_stats[sid].incr_hits;
```
коварна, потому что имеющуюся у меня копию этой строчки нужно изменить в *двух* местах. Также добавлю поле `mult_misses` в `struct thread_stats` и изменю
```
if (c->cmd == PROTOCOL_BINARY_CMD_INCREMENT) {
c->thread->stats.incr_misses++;
} else {
c->thread->stats.decr_misses++;
}
```
на
```
switch (c->cmd) {
case PROTOCOL_BINARY_CMD_INCREMENT: c->thread->stats.incr_misses++; break;
case PROTOCOL_BINARY_CMD_DECREMENT: c->thread->stats.decr_misses++; break;
case PROTOCOL_BINARY_CMD_MULTIPLY: c->thread->stats.mult_misses++; break;
}
```
Строго говоря, нам не требуется менять `add_delta` как таковую, чтобы она, ранее принимавшая `const int incr`, теперь принимала `const int opcode`, но мне такая идея нравится – поэтому изменю.
До состояния «код готов» добрался за 25 минут. Что ж, испробуем!
```
set age 0 3600 2
37
STORED
mult age 10
27
```
Упс.
Возвращаюсь в ту точку, где предположительно должно происходить умножение…
```
if (opcode == 2) {
value *= delta;
```
Ха! Здесь должен использоваться мой новый вариант `PROTOCOL_BINARY_CMD_MULTIPLY`. Исправлю это. Фактически, нужно ввести в grep `opcode ==` и исправить это еще в нескольких местах, ранее упущенных. За 32 минуты дохожу до состояния «код *правда* готов». На сей раз кажется, что код действительно работает как надо. Проведу несколько тестов вручную:
```
set age 0 3600 2
37
STORED
mult age 10
370
mult age 2
740
mult age -1
CLIENT_ERROR invalid numeric delta argument
set fullname 0 3600 10
John Smith
STORED
mult fullname 1
CLIENT_ERROR cannot multiply non-numeric value
mult
ERROR
mult bogus 1
NOT_FOUND
```
Проверяю это поведение на целочисленном циклическом переносе и также проверяю синтаксис `mult age 10 noreply`, чтобы убедиться, что и он поддерживается. Поскольку я все реализовал копипастом, в принципе невозможно представить, чтобы эти вещи *не* работали так же гладко, как в случае с `incr` и `decr`.
Хмм… при всем этом ручном тестировании нужно, пожалуй, написать и несколько настоящих тестов. Есть ли эти тесты в репозитории? Да, под `t/`. Команда `make test` собирает и выполняет их. Поэтому скопирую `t/incrdecr.t` в `t/mult.t` и изменю. Дохожу до стадии «Код *и тесты* готовы» за 50 минут.
*Могу себе представить соискателя, который не станет заморачиваться с модульными тестами, но все равно пройдет собеседование; в конце концов, при собеседовании приоритеты расставляются иначе, чем при пул-реквесте. Поэтому здесь отличное место, где даже полнейший интроверт может оторваться от работы и процедить: «Кажется, уже работает. Не хотите ли взглянуть»?*
Вижу, в `binary.t`. есть еще тесты. Полагаю, и на них следует взглянуть, хотя и не хочется. Ага, точно, там лежит еще одна копия перечисления команд. Я должен туда добавить, как минимум, `CMD_MULTIPLY`.
Также следует добавить в `stats.t` тесты для новой статистики. (А именно, потому, что один из этих тестов просто подсчитывает количество возвращенных статистических показателей, и я бы добавил еще два показателя, так, чтобы тест *не прошел*, если я его не изменю).
Примерно на отметке 60 минут я повторно выхожу на рубеж «код *и тесты* готовы».
Но, продираясь сквозь `t/udp.t`, нахожу там множество тестов, посвященных «двоичному протоколу» (а не протоколу в «обычном тексте», о котором шла речь при постановке задачи). Должен ли я изменить двоичный протокол, равно как и обычный? На самом деле, я это уже сделал, благодаря неизбирательному diff в функции `dispatch_bin_command`.
```
case PROTOCOL_BINARY_CMD_INCREMENT:
case PROTOCOL_BINARY_CMD_DECREMENT:
+ case PROTOCOL_BINARY_CMD_MULTIPLY:
if (keylen > 0 && extlen == 20 && bodylen == (keylen + extlen)) {
bin_read_key(c, bin_reading_incr_header, 20);
} else {
protocol_error = 1;
}
break;
```
Но выше замечаю «тихие» версии тех же самых кодов операций:
```
case PROTOCOL_BINARY_CMD_INCREMENTQ:
c->cmd = PROTOCOL_BINARY_CMD_INCREMENT;
break;
case PROTOCOL_BINARY_CMD_DECREMENTQ:
c->cmd = PROTOCOL_BINARY_CMD_DECREMENT;
break;
```
Не уверен, зачем они нужны, но, чтобы провернуть мой фокус с копипастом в `t/udp.t`, придется добавить один из них в `mult`. (Опять забор Честертона: не знаю, почему важны эти «тихие» коды операций, но, если у `incr` и `decr` они есть, то и в `mult` такой тоже должен быть.) Поэтому добавляю `PROTOCOL_BINARY_CMD_MULTIPLYQ` и распространяю это изменение на всю базу кода.
На данном этапе я просто раз за разом прогоняю `make test` и спотыкаюсь о причуды тестового кода (который весь написан на Perl и полон функций о пяти или шести параметрах). Запоздало осознаю, что некоторые из тестов не проходят только потому, что начинаются с каких-то таинственных пометок вроде “Я [планирую](https://perldoc.perl.org/Test::More#I-love-it-when-a-plan-comes-together) прогнать ровно 95 тест-кейсов», а вот я добавляю лишние тесты – и из-за этого план проваливается.
Примерно через 90 минут считаю, что все сделано. Некоторые тесты на Perl, написанные для двоичного кода, по-прежнему не проходят, но я уверен, что проблема здесь с моими тестами, а не с серверным кодом. Здесь кроется тайный изъян подхода «скопипастить и поменять имена»: тесты на Perl для `incr` в принципе имеют вид
```
initialize num to zero
check that "incr num 1" returns 1
check that "incr num 1" returns 2
check that "incr num 1" returns 3
```
(с обфускацией в несколько уровней косвенности), поэтому, когда я проделываю очевидную операцию с умножением, у меня выходит:
```
initialize num to zero
check that "mult num 1" returns 0
check that "mult num 1" returns 0
check that "mult num 1" returns 0
```
Этот тест никуда не годится. Что ж, если бы *суть* этого челленджа была «сделать хорошие тесты», то я бы потратил на это еще час. Или, если бы я решал рабочую задачу, а не писал пост для блога, тоже потратил бы лишний час. Но для этого поста – довольно.
Заключение
----------
Эта задача по программированию нравится мне как микрокосм, в котором по большей части представлено все, чем приходится заниматься при реальном программировании. Если вы поддерживаете большую базу кода, то всегда в коде найдутся такие пути, которые вы не полностью понимаете, идиомы, которые кажутся ненужными, и большие куски кода, где вы чувствуете себя уверенно и можете на них закрепиться.
Эта задача особенно хорошо подобрана для собеседования, поскольку предполагает лишь один верный ответ: «заменить `bool incr` на `int opcode`» (или любой изоморфный аналог). Вместе эта база кода и постановка задачи весьма ясно подразумевают, что в настоящий момент есть *два* кода для арифметических операций, а ваша задача – довести их количество до *трех*.
Представьте, насколько более разветвленной была бы эта задача, не будь у memcached команды `decr`! Допустим, команда `process_arithmetic_command` называлась бы `process_increment_command`, и `add_delta` не принимала бы `bool incr` в качестве параметра, и т.д. Тогда от соискателя требовалось бы более масштабное творческое решение: *добавить* этот параметр (в какой позиции?) или *клонировать* весь путь кода (начиная с какого уровня?). Клонировать даже одну из этих функций – вероятно, не лучшее решение, но мне могло потребоваться минут двадцать, прежде, чем это осознать.
Представленная задача хорошо составлена, поскольку квалифицированных соискателей сразу направляет по верному пути, а целую категорию неквалифицированных отсекает. В принципе, этот вопрос для инженера как [FizzBuzz](https://imranontech.com/2007/01/24/using-fizzbuzz-to-find-developers-who-grok-coding/) для программиста. И это тоже интересно! Собственно, поэтому я и считаю этот вопрос с технического собеседования лучшим из всех, что мне попадались. | https://habr.com/ru/post/662247/ | null | ru | null |
# Наследование шаблонов в PHP без использования сторонних библиотек
При разработке Web-приложений мы обязательно сталкиваемся с проблемами рендеринга HTML-страниц. Обычно эти проблемы решает шаблонизатор — собственно PHP или какой-нибудь парсер шаблонов. Если приложение большое и страницы содержат множество блоков, то сложность шаблонов может резко возрасти, а у разработчиков появляется желание упростить работу с ними. В ход идут разные техники, но обычно это выделение в шаблонах повторяющихся блоков и правильная их декомпозиция — включая наследование шаблонов.
Мне нравится, как сделано [наследование шаблонов в Django](https://docs.djangoproject.com/en/1.3/topics/templates/#template-inheritance). Идея простая — есть базовый шаблон, в нем выделены контентные блоки, которые будут меняться в зависимости от страницы. При рендеренге страницы можно указать, что за основу берется базовый шаблон и переопределить только нужные блоки. Если в проекте много однотипных страниц, то можно сделать промежуточный шаблон, наследующий от главного, а затем переопределять его данные. При умелом проектировании количество повторяющегося кода можно свести на нет, а также облегчить жизнь при изменении дизайна.
Похоже этот подход нравится не только мне и разработчикам Django, но и Fabien Potencier автору фреймворка Symfony и шаблонизатора [Twig](http://twig.sensiolabs.org/). Twig обладает множеством интересных функций, включая компиляцию шаблонов в нативные PHP-классы, фильтрацию данных, встроенными циклами и т.д. — в общем всем тем, что полагается иметь современному шаблонизатору. Но самое интересное — это то самое наследование шаблонов, о котором я говорил выше. Вот пример из официальной документации:
Базовый шаблон:
```
{% block head %}
{% block title %}{% endblock %} - My Webpage
{% endblock %}
{% block content %}{% endblock %}
{% block footer %}
© Copyright 2011 by [you](http://domain.invalid/).
{% endblock %}
```
Дочерний шаблон:
```
{% extends "base.html" %}
{% block title %}Index{% endblock %}
{% block head %}
{{ parent() }}
.important { color: #336699; }
{% endblock %}
{% block content %}
Index
=====
Welcome on my awesome homepage.
{% endblock %}
```
В базовом шаблоне определены основные блоки, а в дочернем — пример их переопределения. Копания в исходных кодах показало, что реализуется это наследование также нативно — путем наследования “скомпилированных” классов. Отличная идея! Все хорошо, но меня несколько смущала необходимость изучения пусть простого, но все-таки отличного от PHP синтаксиса шаблонизатора. А моя нелюбовь к ненативным шабонам началась еще со Smarty (в котором тоже есть наследование) и до сегодняшнего дня не претерпела существенных изменений.
Совсем близко к иделу подошел разработчик из Сан-Франциско [Adam Shaw](http://arshaw.com/). Очевидно, он также как и я не любит эксперименты с синтаксисом шаблонизаторов и придумал незамысловато названную библиотеку [Template Inheritance](http://phpti.com/) На сайте жирным по желтому написано, что «There is no need to learn another template language», мол не нужно учить другой язык шаблонов. С этим я согласен. Что же он предлагает? Смотрим пример опять же из официальной документации:
Базовый шаблон:
```
php require_once 'ti.php' ?
php startblock('title') ?
php endblock() ?
=============================================
php startblock('article') ?
php endblock() ?
```
Дочерний шаблон:
```
php include 'base.php' ?
php startblock('title') ?
This is the title
php endblock() ?
php startblock('article') ?
This is the article
php endblock() ?
```
Синтаксис натуральный, блоки выделены явно, подключил библиотеку в базовый шаблон и забыл. Все. Автор говорит, что сделал это с помощью [буферов](http://php.net/manual/en/function.ob-start.php) и стека (возможны вложенные блоки). Код действительно интересный, но пестрит наличием глобальных переменных. Чего же остается ещё желать?
Вот здесь-то мы и подходим к главной теме нашего повествования. А не сможет ли PHP сам переопределить блоки базового шаблона? Я думаю, что вполне! Смотрите:
Вот базовый шаблон:
```
php echo isset($title) ? $title : ''; ?
php if(isset($content)){echo $content}else{ ?
Default content
php }?
php if(isset($sidebar)){echo $sidebar}else{ ?
Default sidebar
php }?
```
Здесь в 3 блоках шаблона проверяется наличие соответствующей переменной, хранящей некоторый контент и, если она присутствует в области видимости, то ее можно выводить в шаблон, а если нет, то выводится контент по-умолчанию. Нам остается только переопределить эти переменные в дочернем шаблоне. А вот собственно и он:
```
php if(!isset($content)){ ob_start(); ?
Переопределенный контент
========================
php $content = ob_get_clean();} ?
php require 'baseTemplate.php'; ?
```
В этом примере переопределяется переменная $content, если она не была установлена заранее. Это сделано для того, чтобы была возможность наследовать этот шаблон и переопределить блок контента. Думаю, идея понятна. Не требуется никаких библиотек — просто пишите шаблоны в таком стиле и будет вам счастье.
Конечно, и здесь не обошлось без недостатков. Во-первых, это не очень лаконичный синтаксис определения и переопределения блоков: расплата за нативность. Во вторых, в дочернем шаблоне нельзя получить код родительского блока. В-третьих, при таком способе включения шаблонов перед собственно HTML-кодом может образоваться некоторое количество пробелов из-за отступов между блоками. Здесь я бы посоветовал подключать шаблон также с помощью буферов и фильтровать контент. Так делается во многих фреймворках:
```
function render($pathToTemplate, $data)
{
extract($data);
ob_start();
require $pathToTemplate;
return trim(ob_get_clean());
}
```
Эта функция возвращает вывод шаблона из файле $pathToTemplate с подстановкой переменных, полученных из массива $data. extract — на любителя — можно и не делать, а обращаться напрямую к $data. Перед выводом из контента убираются начальные и конечные пробелы. В шаблоне можно делать все, что позволит делать ваша совесть, не нарушая принципы разделения логики и представления, и PHP. Например, в зависимости от ситуации подключать тот или иной базовый файл.
Вот и все. Для реализации наследования можно использовать любой из описанных выше методов, уверен, что есть еще что-то. Буду рад, если эта статья поможет кому-то сделать свой код немного лучше. | https://habr.com/ru/post/134421/ | null | ru | null |
# PostgreSQL 16: Часть 1 или Коммитфест 2022-07
Август в релизном цикле PostgreSQL месяц особенный. Еще не вышла официально 15-я версия, но уже закончился [первый коммитфест](https://commitfest.postgresql.org/38/) 16-й версии. И мы можем посмотреть на самые интересные изменения.
Собираем сервер из [исходного кода](https://git.postgresql.org/gitweb/?p=postgresql.git;a=summary) и вперед!
```
\dconfig server_version
```
```
List of configuration parameters
Parameter | Value
----------------+---------
server_version | 16devel
```
PostgreSQL 15
-------------
После заморозки кода 15-й версии не обошлось без потерь. Откатили:
[Индексы BRIN не блокируют HOT-обновления](https://habr.com/ru/company/postgrespro/blog/596567#commit_e3fcca0d)
[Оптимизация работы с вложенными транзакциями](https://habr.com/ru/company/postgrespro/blog/679264/#commit_06f5295a)
PostgreSQL 16
-------------
В этот обзор попали 14 изменений:
[psql: \pset xheader\_width](#commit_a45388d6)
[vacuumdb --schema и --exclude-schema](#commit_7781f4e3)
[Новые возможности утилиты createuser](#commit_08951a7c)
[Сообщение журнала о контрольной точке дополнили номерами LSN самой точки и начала восстановления](#commit_62c46eee)
[pg\_prepared\_statements.result\_types](#commit_84ad713c)
[auto\_explain: параметр log\_parameter\_max\_length](#commit_d4bfe412)
[Необязательные псевдонимы для подзапросов во фразе FROM](#commit_bcedd8f5)
[REINDEX: синтаксис и не только](#commit_2cbc3c17)
[CREATE STATISTICS: необязательно указывать имя статистики](#commit_624aa2a1)
[CREATE TABLE: атрибут STORAGE](#commit_784cedda)
[У созданного при инициализации кластера пользователя нельзя отобрать полномочия суперпользователя](#commit_e530be2c)
[Триггеры на TRUNCATE для внешних таблиц](#commit_3b00a944)
[pg\_read\_file/pg\_read\_binary\_file: новая вариация указания параметров](#commit_283129e3)
[Собственные менеджеры ресурсов WAL](#commit_5c279a6d)
**[psql: \pset xheader\_width](https://commitfest.postgresql.org/38/3295/)**
commit: [a45388d6](https://github.com/postgres/postgres/commit/a45388d6)
Развернутый режим вывода результатов запросов (\x или \pset expanded) удобен когда данные всех столбцов не помещаются на экран. Но и в развернутом режиме данные длинных столбцов также могут не помещаться в окно терминала.
Для примера в окне терминала шириной в 72 символа выполним запрос:
```
\pset expanded on
\pset pager off
SELECT version(),
length(version()) version_length;
```
```
-[ RECORD 1 ]--+--------------------------------------------------------
-------------------------------------------------
version | PostgreSQL 16devel on x86_64-pc-linux-gnu, compiled by
gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0, 64-bit
version_length | 104
```
Значение функции version не помещается по ширине, поэтому переносится на следующую строку. С этим все нормально. Но вот строка заголовка записи форматируется по самому широкому столбцу и также переносится на следующую строку. И чем длиннее самый широкий столбец, тем больше места будет занимать строка заголовка записи. Это особенно неудобно, когда выводится несколько записей и у каждой записи заголовок занимает несколько строк. (Попробуйте выполнить в развернутом режиме запрос `SELECT * FROM pg_proc;`)
В 16-й версии в psql появился новый параметр форматирования строки заголовка развернутого режима.
```
\pset xheader_width
```
```
Expanded header width is 'full'.
```
Значение по умолчанию (full) соответствует поведению в предыдущих версиях. Другие возможные значения:
* column ― заголовок записи обрезается до ширины первого столбца вывода;
* page ― заголовок записи обрезается до ширины окна терминала;
* *число* ― заголовок записи обрезается до указанного числа.
```
\pset xheader_width column
```
```
Expanded header width is 'column'.
```
```
SELECT version(),
length(version()) version_length;
```
```
-[ RECORD 1 ]--+
version | PostgreSQL 16devel on x86_64-pc-linux-gnu, compiled by
gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0, 64-bit
version_length | 104
```
Заголовок записи больше не расходует напрасно полезное место окна терминала.
**[vacuumdb --schema и --exclude-schema](https://commitfest.postgresql.org/38/3612/)**
commit: [7781f4e3](https://github.com/postgres/postgres/commit/7781f4e3)
У vacuumdb новые параметры для очистки таблиц в указанных схемах (--schema) или таблиц, не принадлежащих указанным схемам (--exclude-schema).
**[Новые возможности утилиты createuser](https://commitfest.postgresql.org/38/3618/)**
commit: [08951a7c](https://github.com/postgres/postgres/commit/08951a7c)
Утилита createuser является оберткой над командой CREATE ROLE, но с ограниченным функционалом. Это изменение добавляет утилите ряд параметров, реализующих отсутствующие ранее возможности, а именно:
* --valid-until для формирования фразы VALID UNTIL;
* --bypassrls/--no-bypassrls для формирования атрибута BYPASSRLS/NOBYPASSRLS;
* -m/--member для включения создаваемой роли в указанную роль;
* -a/--admin для включения создаваемой роли в указанную роль с предложением WITH ADMIN OPTION.
**[Сообщение журнала о контрольной точке дополнили номерами LSN самой точки и начала восстановления](https://commitfest.postgresql.org/38/3474/)**
commit: [62c46eee](https://github.com/postgres/postgres/commit/62c46eee)
После завершения контрольной точки в WAL делается запись с номером LSN контрольной точки и номером LSN, откуда начинать восстановление в случае сбоя (redo LSN).
Для последней выполненной контрольной точки эти два номера LSN записываются в управляющий файл:
```
$ pg_controldata | egrep 'Latest.*location'
```
```
Latest checkpoint location: 1/1A3DEB20
Latest checkpoint's REDO location: 1/1A3DEAE8
```
А в 16-й версии их добавили в сообщение о завершении контрольной точки журнала сервера:
```
2022-08-02 12:15:17.961 MSK [198868] LOG: checkpoint complete: wrote 0 buffers (0.0%); 0 WAL file(s) added, 0 removed, 0 recycled; write=0.001 s, sync=0.001 s, total=0.072 s; sync files=0, longest=0.000 s, average=0.000 s; distance=0 kB, estimate=418462 kB; lsn=1/1A3DEB20, redo lsn=1/1A3DEAE8
```
Стоит напомнить, что начиная с 15-й версии параметр *log\_checkpoints* включен по умолчанию.
**[pg\_prepared\_statements.result\_types](https://commitfest.postgresql.org/38/3644/)**
commit: [84ad713c](https://github.com/postgres/postgres/commit/84ad713c), [6ffff0fd](https://github.com/postgres/postgres/commit/6ffff0fd)
В представление pg\_prepared\_statements добавили столбец result\_types.
```
PREPARE get_booking (text) AS
SELECT * FROM bookings WHERE book_ref = $1;
SELECT * FROM pg_prepared_statements WHERE name = 'get_booking'\gx
```
```
-[ RECORD 1 ]---+-----------------------------------------------
name | get_booking
statement | PREPARE get_booking (text) AS +
| SELECT * FROM bookings WHERE book_ref = $1;
prepare_time | 2022-08-02 16:54:14.313221+03
parameter_types | {text}
result_types | {character,"timestamp with time zone",numeric}
from_sql | t
generic_plans | 0
custom_plans | 0
```
Для подготовленных операторов без возвращаемого значения, столбец будет оставаться пустым.
**[auto\_explain: параметр *log\_parameter\_max\_length*](https://commitfest.postgresql.org/38/3660/)**
commit: [d4bfe412](https://github.com/postgres/postgres/commit/d4bfe412)
Новый параметр расширения *auto\_explain.log\_parameter\_max\_length* выполняет ту же задачу, что и аналогичный *log\_parameter\_max\_length*, а именно ― журналирует значения параметров запросов.
```
LOAD 'auto_explain';
SHOW auto_explain.log_parameter_max_length;
```
```
auto_explain.log_parameter_max_length
---------------------------------------
-1
(1 row)
```
Значение по умолчанию равно -1. Это говорит о том, что будут выводиться полные значения параметров. Значение 0 отключает вывод значений параметров, положительное число ограничивает вывод значений указанным количеством байт.
Настроим журналирование и сформируем параметризированный запрос командой EXECUTE… USING в анонимном блоке PL/pgSQL.
```
SET auto_explain.log_min_duration = 0;
SET auto_explain.log_nested_statements = 'on';
SET auto_explain.log_level = 'NOTICE';
DO $$BEGIN EXECUTE 'SELECT $1' USING 42; END;$$;
```
```
NOTICE: duration: 0.003 ms plan:
Query Text: SELECT $1
Query Parameters: $1 = '42'
Result (cost=0.00..0.01 rows=1 width=4)
DO
```
В вывод добавилась строка Query Parameters, позволяющая узнать, с какими значениями выполнялся запрос в строке Query Text.
**[Необязательные псевдонимы для подзапросов во фразе FROM](https://commitfest.postgresql.org/38/3714/)**
commit: [bcedd8f5](https://github.com/postgres/postgres/commit/bcedd8f5)
Для подзапросов во фразе FROM стандарт SQL требует наличия псевдонима:
```
15=# SELECT * FROM (SELECT 42 AS a);
```
```
ERROR: subquery in FROM must have an alias
LINE 1: SELECT * FROM (SELECT 42 AS a);
^
HINT: For example, FROM (SELECT ...) [AS] foo.
```
Однако это осложняет миграцию с других СУБД, где наличие псевдонима необязательно.
В 16-й версии такие псевдонимы не обязательны и в PostgreSQL.
```
16=# SELECT * FROM (SELECT 42 AS a);
```
```
a
----
42
(1 row)
```
**[REINDEX: синтаксис и не только](https://commitfest.postgresql.org/38/3636/)**
commit: [2cbc3c17](https://github.com/postgres/postgres/commit/2cbc3c17)
Варианты команды REINDEX DATABASE и REINDEX SYSTEM требовали указания базы данных. Но указать можно только текущую базу данных, что делает это требование излишним. В новой версии имя базы данных становится необязательным.
Кроме того, команда REINDEX DATABASE теперь переиндексирует только пользовательские индексы и пропускает индексы таблиц системного каталога. Прежнего поведения, а именно перестроения всех индексов базы данных, можно добиться выполнением двух команд REINDEX DATABASE и REINDEX SYSTEM.
Такое изменение обосновано тем, что до сих пор не было способа перестроить только пользовательские индексы во всей базе данных. К тому же перестроение системных индексов невозможно в режиме CONCURRENTLY, а в высоконагруженных системах может вызывать взаимоблокировки.
**[CREATE STATISTICS: необязательно указывать имя статистики](https://commitfest.postgresql.org/38/3708/)**
commit: [624aa2a1](https://github.com/postgres/postgres/commit/624aa2a1)
Расширенная статистика ― отдельный объект в базе данных и нуждается в имени. Но почему бы не разрешить опускать имя при создании, доверив его формирование самой СУБД? Точно так же, как это возможно для индексов и ограничений целостности.
Сделали:
```
CREATE STATISTICS ON departure_airport, arrival_airport FROM flights;
\d flights
```
```
...
Statistics objects:
"bookings.flights_departure_airport_arrival_airport_stat" ON departure_airport, arrival_airport FROM flights
```
**[CREATE TABLE: атрибут STORAGE](https://commitfest.postgresql.org/38/3479/)**
commit: [784cedda](https://github.com/postgres/postgres/commit/784cedda)
Предположим, мы решили хранить изображения в базе данных. Создаем таблицу:
```
CREATE TABLE images (filename text, data bytea);
ALTER TABLE images ALTER COLUMN data SET STORAGE external;
```
Во второй команде меняем стратегию хранения TOAST на external, чтобы запретить сжатие данных. Ведь файлы изображений и так сжаты.
Вопрос в том, зачем это делать отдельной командой, а не сразу указать нужную стратегию в CREATE TABLE? Ответ простой: CREATE TABLE до 16-й версии не позволяет указывать атрибут STORAGE для столбцов, что и было исправлено:
```
CREATE TABLE images (filename text, data bytea STORAGE external);
```
**[У созданного при инициализации кластера пользователя нельзя отобрать полномочия суперпользователя](https://www.postgresql.org/message-id/flat/CA%2BTgmoZirCwArJms_fgvLBFrC6b%3DHdxmG7iAhv%2Bkt_%3DNBA7tEw%40mail.gmail.com)**
commit: [e530be2c](https://github.com/postgres/postgres/commit/e530be2c)
Суперпользователь, созданный при инициализации кластера (pg\_authid.oid=10), мог сам у себя отобрать атрибут SUPERUSER:
```
15=# ALTER ROLE postgres NOSUPERUSER;
```
(Если другого суперпользователя нет, то чтобы вернуть атрибут придется запускать сервер в однопользовательском режиме.)
В 16-й версии случайно лишиться суперпользовательских полномочий не получится:
```
16=# ALTER ROLE postgres NOSUPERUSER;
```
```
ERROR: permission denied: bootstrap user must be superuser
```
Кстати, удалить суперпользователя, созданного при инициализации кластера было и раньше нельзя:
```
CREATE ROLE root LOGIN SUPERUSER;
\c - root
DROP ROLE postgres;
```
```
ERROR: cannot drop role postgres because it is required by the database system
```
Общий вывод можно сделать такой. Начальный суперпользователь необходим для нормального функционирования сервера. Удалять или отнимать у него привилегии не нужно. В плане обеспечения дополнительной безопасности можно [подумать](https://www.postgresql.org/message-id/f941fa4a-a294-165a-82c4-947d3c8425f6%40joeconway.com) о том, чтобы сделать эту роль групповой, забрав атрибут LOGIN.
**[Триггеры на TRUNCATE для внешних таблиц](https://www.postgresql.org/message-id/flat/20220630193848.5b02e0d6076b86617a915682%40sraoss.co.jp)**
commit: [3b00a944](https://github.com/postgres/postgres/commit/3b00a944)
Некоторые обертки сторонних данных поддерживают команду TRUNCATE. Этот патч добавляет возможность создавать триггер на TRUNCATE для внешних таблиц таких оберток.
**[pg\_read\_file/pg\_read\_binary\_file: новая вариация указания параметров](https://commitfest.postgresql.org/38/3730/)**
commit: [283129e3](https://github.com/postgres/postgres/commit/283129e3)
Спецификация функций pg\_read\_file и похожей pg\_read\_binary\_file была такой:
```
pg_read_file ( filename text [, offset bigint, length bigint [, missing_ok boolean ]] ) → text
```
Предполагается, что для чтения файла целиком нужно не указывать параметры offset и length. Но тогда не получается задать missing\_ok=true для игнорирования отсутствия файла.
В 16-й версии добавили еще один перегруженный вариант функций, что привело общую спецификацию к виду:
```
pg_read_file ( filename text [, offset bigint, length bigint ] [, missing_ok boolean ] ) → text
```
Теперь можно указать только имя файла и игнорировать его отсутствие.
**[Собственные менеджеры ресурсов WAL](https://commitfest.postgresql.org/38/3469/)**
commit: [5c279a6d](https://github.com/postgres/postgres/commit/5c279a6d)
Особую роль патча подчеркивает мой коллега, Егор Рогов. Ему и слово.
Одна из проблем, стоящих перед разработчиками табличных и индексных методов доступа — невозможность формировать журнальные записи специфического вида. Существует механизм [унифицированных журнальных записей](https://postgrespro.ru/docs/postgresql/14/generic-wal), который сбрасывает в WAL “разницу” между старым и новым состояниями страницы (им пользуется, например, расширение [rum](https://github.com/postgrespro/rum)), но он не слишком эффективен и не поддерживает логическую репликацию.
В версии 16 расширения смогут создавать [собственные менеджеры ресурсов](https://www.postgresql.org/docs/15/custom-rmgr.html) и, соответственно, журнальные записи собственного формата. Обратная сторона медали в том, что восстановление экземпляра после сбоя становится зависимым от стороннего расширения.
С точки зрения пользователя патч ничего не меняет, но это еще один важный шаг на пути к появлению новых методов доступа.
---
На этом пока всё. Ждем следующего [сентябрьского коммитфеста](https://commitfest.postgresql.org/39/) и, конечно же, официального выхода 15-й версии. | https://habr.com/ru/post/681164/ | null | ru | null |
# Работа с игровыми контроллерами
Приветствую, дорогие читатели!
В одном из проектов мне понадобилось работать с [игровыми контроллерами](http://ru.wikipedia.org/wiki/%D0%98%D0%B3%D1%80%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D0%BB%D0%B5%D1%80), в частности с игровым рулем. Было необходимо получить состояние руля – угол поворота, нажатые кнопки. Создавалась не игра, это было обычное .net-приложение, не буду вдаваться в подробности проекта. Речь пойдет о том, как получить информацию о состоянии игровых контроллеров в .net.
#### Предметная область
Задача – получить данные от игрового руля. В первую очередь необходимо изучить предметную область. Где используются игровые рули? Очевидно, в играх. Множество игр разрабатывается с помощью технологии DirectX. Почитав [википедию](http://ru.wikipedia.org/wiki/DirectX), можно узнать, что DirectX подразделяется на множество интерфейсов. Интерес для нас представляет интерфейс DirectInput.
> **DirectInput** — интерфейс, используемый для обработки данных, поступающих с клавиатуры, мыши, джойстика и пр. игровых контроллеров. (с) [Wikipedia.org](http://ru.wikipedia.org/wiki/DirectX#DirectX_API)
#### Используемые игровые контроллеры
Для реализации проекта в мое распоряжение был предоставлен игровой руль [Defender Forsage GTR](http://www.defender.ru/products/game/wheel/forsage-gtr/).
Также я не упустил возможности поэкспериментировать со своим игровым джойстиком [Logitech Rumblepad 2](http://www.logitech.com/ru-ru/gaming/controllers/devices/264).
#### Managed DirectX
Как Вы, наверное, догадались [Managed DirectX](http://en.wikipedia.org/wiki/Managed_DirectX) — это поддержка DirectX из управляемого кода, т.е. из программ, написанных с использованием .net. MDX включен в состав DirectX SDK, начиная с девятой версии.
Если Вы заинтересовались MDX, то можете почитать книгу Тома Миллера «DirectX 9 с управляемым кодом. Программирование игр и графика». В сети есть масса информации по теме.
#### Необходимые инструменты
Логично, что в первую очередь необходимо инсталлировать драйвер производителя игрового контроллера, хотя, как выяснилось, это не является обязательным пунктом, т.к. в ходе моих экспериментов с джойстиком Logitech, никаких драйверов для него я не инсталлировал, и он стабильно отвечал на мои запросы (под управлением ОС Windows 7).
Мы используем DirectX, поэтому нам понадобится DirectX SDK, скачать его можно [здесь](http://www.microsoft.com/downloads/info.aspx?na=41&srcfamilyid=3021d52b-514e-41d3-ad02-438a3ba730ba&srcdisplaylang=en&u=http%3a%2f%2fdownload.microsoft.com%2fdownload%2fA%2fE%2f7%2fAE743F1F-632B-4809-87A9-AA1BB3458E31%2fDXSDK_Jun10.exe). Все необходимое для работы с .net там уже есть. В качестве IDE я использовал Visual Studio 2010.
#### Начало работы
Итак, DirectX SDK установлен, запустим Visual Studio, создадим новый проект и подключим к нему Managed DirectX. Для этого идем в **References** -> **Add Reference**, идем во вкладку **Browse**, идем в папку **\Windows\Microsoft.NET\DirectX for Managed Code\1.0.2902.0** и подключаем к проекту **Microsoft.DirectX.dll** и **Microsoft.DirectX.DirectInput.dll**, соответственно не забываем про:
```
using Microsoft.DirectX;
using Microsoft.DirectX.DirectInput;
```
Конечно, не обошлось без подводных камней. В своих проектах в основном я использую .net framework 4.0, а у MDX проблемы с этой версией фреймворка, и на этапе сборки проекта Visual Studio 2010 просто зависнет. Поэтому у нас есть два пути решения проблемы:
1) использовать более раннюю версию .net framework.
2) немного подправить конфиги проекта, что мы и сделаем.
Добавим к проекту новый файл **app.config** со следующим содержимым:
```
xml version="1.0"?
```
Теперь все готово, можно начинать работать с игровыми контроллерами.
#### Получение состояния игрового руля
Очевидно, что первым делом необходимо узнать обо всех подключенных игровых контроллерах:
```
foreach (DeviceInstance instance in Manager.GetDevices(DeviceClass.GameControl, EnumDevicesFlags.AttachedOnly))
{
// На этом этапе можно узнать информацию об игровом контроллере, например, название:
instance.ProductName
}
```
Далее необходимо инициализировать игровое устройство. Для наглядности подразумеваю, что оно у меня одно:
```
Device device;
foreach (DeviceInstance instance in Manager.GetDevices(DeviceClass.GameControl, EnumDevicesFlags.AttachedOnly))
{
device = new Device(instance.ProductGuid);
// Background - флаг, говорит о том, что данные от руля будут поступать даже в неактивное окно
// NonExclusive - говорит о том, что игровой контроллер могут использовать и другие приложения
device.SetCooperativeLevel(null, CooperativeLevelFlags.Background | CooperativeLevelFlags.NonExclusive);
// Зададим дополнительные параметры
foreach (DeviceObjectInstance doi in device.Objects)
{
// Проверяем есть ли на устройстве что-нибудь поворачивающееся
if ((doi.ObjectId & (int)DeviceObjectTypeFlags.Axis) != 0)
{
// Задаем минимальное и максимальное значение угла поворота
device.Properties.SetRange(
ParameterHow.ById,
doi.ObjectId,
new InputRange(-90, 90));
}
}
// Применяем настройки
device.Acquire();
}
```
В [характеристиках](http://www.defender.ru/products/game/wheel/forsage-gtr/) руля сказано, что угол поворота рулевого колеса составляет 180 градусов, поэтому в *InputRange* я указал значение угла отклонения влево и вправо в 90 градусов.
К сожалению, мы не сможем подписаться на какие-либо события от руля или джойстика вроде *KeyDown\KeyUp*, и состояние игрового контроллера придется опрашивать вручную:
```
// Создаем таймер
DispatcherTimer timer = new DispatcherTimer();
timer.Tick += new EventHandler(timer_Tick);
timer.Interval = new TimeSpan(0, 0, 0, 0, 10);
timer.Start();
private void timer_Tick(object sender, EventArgs e)
{
// Получим текущее состояние руля
JoystickState j = device.CurrentJoystickState;
string info = "";
// Собираем информацию о кнопках
byte[] buttons = j.GetButtons();
for (int i = 0; i < buttons.Length; i++)
{
// Узнаем какие из кнопок нажаты на данный момент
if (buttons[i] != 0)
{
info += "Button: " + i + " ";
}
}
// j.X будет содержать информацию об угле поворота руля
textBlock1.Text = j.ToString();
textBlock2.Text = info;
}
```
Для наглядности можно вывести на экран структуру *JoystickState* и увидеть, какие поля меняются в зависимости от состояния игрового руля. Все это справедливо также и для джойстика.
#### Выводы
Оказывается, запрограммировать игровой контроллер под свои нужды не так уж и сложно, большинство всевозможных джойстиков\рулей и т.п. подчиняются интерфейсу DirectInput, теперь в свои проекты\игры вы с легкостью сможете добавить их поддержку. Что касается игр, то остается только реализовать функционал, дающий пользователю возможность самому «навешивать» на кнопки действия, предусмотренные логикой игры.
#### Ссылки
1. [DirectX Software Development Kit June 2010 \ 572 Mb](http://www.microsoft.com/downloads/info.aspx?na=41&srcfamilyid=3021d52b-514e-41d3-ad02-438a3ba730ba&srcdisplaylang=en&u=http%3a%2f%2fdownload.microsoft.com%2fdownload%2fA%2fE%2f7%2fAE743F1F-632B-4809-87A9-AA1BB3458E31%2fDXSDK_Jun10.exe)
2. [Том Миллер — Managed DirectX 9 с управляемым кодом](http://www.ozon.ru/context/detail/id/2167854/)
3. [Исходники демонстрационного проекта](http://narod.ru/disk/19952437001/WheelWpf.rar.html)
Спасибо за внимание. | https://habr.com/ru/post/124851/ | null | ru | null |
# Опыт разработки первой игры на Unity, часть 4
* [Ссылка на часть 1](https://habr.com/ru/post/593399/)
* [Ссылка на часть 2](https://habr.com/ru/post/593401/)
* [Ссылка на часть 3](https://habr.com/ru/post/594069/)
### Или о том, как я обманываю читателей
Дело в том, что я снова ошибся в планах - причем опять на том же самом месте! Вновь для того, чтобы сделать прокачку героев, мне перед этим нужно реализовать другой функционал.
Беда в том, что только участвующие в битве герои должны получать опыт (хотя тут есть важный геймплейный нюанс, о котором в другой раз), а в текущей архитектуре это невозможно. Могу придумать какой-нибудь костыль, но гораздо лучше будет, если сделаю все правильно (ну, в моем представлении)
Поэтому перед повышением уровня нужно сначала сделать выбор участвующих в битве героев
### Подготовка
Для начала нужно добавить интерфейс, в котором и будет происходить выбор героев для битвы.
* Снизу экрана должны отображаться все имеющиеся у игрока герои
* Сверху - просто расположение выбранных героев на поле битвы
* Хочу кликнуть по герою - и чтоб он появился сверху
* Еще хочу уметь перетаскивать героев сверху на разные позиции
### Реализация
Пыщь-пыщь - немного магии - и готово.
Упс - что-то пошло не так. Лезем обратно в код - и получаем вот такое чудо:
Дело нехитрое, но как же ужасно выглядит! Давайте договоримся: вы сделаете вид, что не замечаете интерфейс. Под UI / UX выделен отдельный пункт плана работ - и какой же кошмар меня ожидает! Тут можно заметить, что весь экран по центру разделен на две части: с квадратами и - вот неожиданность - другими квадратами (причем снизу кнопки). Итак, что тут:
Герои снизу - просто кнопки. Нажимаю, и он появляется в первой доступной ячейке. Нажимаю вновь - пропадает. Запускаю бой - в битве участвуют только выбранные герои - причем на нужных позициях! Не верите? А вот:
### Трудности - куча их!
И знаете, что тут оказалось самым сложным? Ни за что не угадаете! Появление героя в нужной ячейке при нажатии на кнопку. Как я с этим намучался. Оказалось, что нельзя просто взять и сделать так, чтобы объект просто заменялся на нужный. Ну или я просто не сообразил, как так делается.
В Unity можно сделать "выключенные" объекты - они как бы есть, но движок их не обрабатывает (соответственно, игрок их не увидит). Был вариант “сделать сюда кучу героев и деактивировать их. А потом в нужный момент просто активировать нужного". Спасибо за генерацию идей - сказал я себе, - и принялся думать дальше. В итоге сейчас просто нужному объекту присваивается спрайт нужного мне героя. Уии, магия!
Осталось немного - нужно уметь менять героев местами перетаскиванием в разные точки. Сделал 1 в 1 как в этом видео:
<https://youtu.be/BGr-7GZJNXg>
Вот тут возникла неприятная особенность - на этапе продумывания я понятия не имел, как сделать так, чтобы герои именно менялись местами. Это казалось абсолютно непонятным. То есть, в общих чертах я представлял, как нужно делать, но детали казались абсолютно непонятными. Это стало в том числе причиной следующего.
### Выгорание, ты ли это?
Примерно тут мне все начало слегка так надоедать. Код разрастается, понимаю я в нем все меньше и меньше. Для того, чтобы делать новые фишки, приходится перелопачивать старые. Усугубляется тем, что сейчас я не слишком следую плану. Делая что-то сейчас, я стараюсь учитывать, какие еще фичи должны быть поверх текущих или параллельно им. И из-за этого приходится делать много чего, что не связано с текущей задачей - а это по ощущениям сильно замедляет скорость работы.
Справится с этим можно довольно просто: более качественно декомпозировать задачи - тогда сама разработка будет более последовательна, и не придется скакать туда-сюда. Но, если честно, не уверен, что это вообще возможно. И это при том, что у меня есть конечный список того, что мне нужно в минимальной рабочей версии - ничего сверх него я не собираюсь добавлять.
Как итог - я так и не придумал, как сделать так, чтобы герои менялись местами при перетаскивании одного на другого. Подозреваю, это не просто. Скорее всего, это *очень* просто. Беда в том, что это важный UX - элемент, без которого игрок будет чувствовать много боли. И оставлять это недоделанным - такое себе…
С другой стороны, я очень долго с этим вожусь, мне нужно передохнуть. К тому же, я сделал так, что работу над этой фичей можно продолжить в любой момент - ее отсутствие / реализация не потребует изменений уже сделанного.
Ох и нагнал я негатива. Да, было не очень комфортно - но гляньте на результат! Настоящая магия!
### А как работает, семпай?
А теперь ваша любимая часть! Сердце сего шедевра, его мозг. Путь, по которому движется сей самурай. Движок, бьющийся… Ладно, ладно, прекращаю. Встречайте: то, от чего у программистов появляется непреодолимое желание взять учебник по языку и дать его почитать - код!
Правда, никаких неординарных задач тут нет
При нажатии по герою снизу он заполняет первую свободную ячейку сверху. При этом отправляет выбранных героев в архив "активных героев" - именно они будут участвовать в битве:
```
public void SetPlace()
{
for (int i = 0; i < _changeHeroesOnBattle.HeroesPlaceholders.Count; i++)
{
if (_changeHeroesOnBattle.IsEmpty[i] && !_isPressed)
{
_changeHeroesOnBattle.EmptyHeroPosition.GetChild(i).gameObject.SetActive(true);
_changeHeroesOnBattle.EmptyHeroPosition.GetChild(i).GetChild(0).GetComponent().sprite = GetComponent().sprite;
_changeHeroesOnBattle.EmptyHeroPosition.GetChild(i).GetChild(1).GetComponent().text = \_heroID.text;
\_changeHeroesOnBattle.IsEmpty[i] = false;
\_changeHeroesOnBattle.ActiveHeroes.Add(\_hero);
\_changeHeroesOnBattle.ActiveHeroes[i].GetComponent().StartPosition = \_spawner.transform.GetChild(0).GetChild(i).position;
\_changeHeroesOnBattle.ActiveBtnsSkills.Add(\_hero.GetComponent().SkillUI);
\_isPressed = true;
break;
}
else if (!\_changeHeroesOnBattle.IsEmpty[i]
&& \_changeHeroesOnBattle.EmptyHeroPosition.GetChild(i).GetChild(1).GetComponent().text == \_heroID.text
&& \_isPressed)
{
\_changeHeroesOnBattle.ResetPlaceholder(i);
\_changeHeroesOnBattle.ActiveHeroes.Remove(\_hero);
\_changeHeroesOnBattle.ActiveBtnsSkills.Remove(\_hero.GetComponent().SkillUI);
\_isPressed = false;
break;
}
}
}
```
И... Это все xD
Заключе… Ох, стоп. Это что, продолжение?
### Воу, статья еще не кончилась?
Да-да, в этом выпуске будет больше одной фичи! Помните повышение уровня? Теперь сделаю… Нет, еще не его.
Для повышения уровня рассматривал несколько вариантов:
* Герой получает опыт при каждом убийстве противника. Максимально приближенный к “большим” РПГ игровой опыт
* Герои получают опыт только после победы над каждой волной противников
* Герои получают опыт только после победы над всеми противниками
Изначально хотел сделать первый вариант, но остановило то, что герои будет увеличивать уровень чуть ли не после каждого убийства. А при повышении восстанавливается здоровье. Они же не убиваемыми получатся! Это можно решить, назначив требованием к level up "получить 9000 опыта", но я хочу игрока награждать почаще. Остальные варианты в своей сути одинаковы.
К чему это я? Остался последний штрих перед повышением уровня - игра должна знать о нашей победе или поражении. Иии… Тут без сюрпризов: добавить UI панели - разместить нужные картинки и текст - вжух-вжух - и готово!
Решил не делать красивую анимацию “перетекания” полученного опыта в героя (чтоб красиво так повышался уровень). Пока просто отображает, сколько опыта герой получил за битву. Чуть не забыл! Выбранные в битву герои сохраняют свои позиции даже после битвы - красота.
### Добро пожаловать в школу программирования
И вновь - попытка поехать на велосипеде с помощью костылей и какого-то чуда
Вот. Вот оно - то, с чем я возился больше 10 часов. И я не шучу. В поисках этого решения я перерыл весь интернет. Вы готовы?
```
if (_battleStarterScript.ActiveEnemies.All(ActiveEnemies =>
ActiveEnemies.GetComponent().IsDead))
```
Проверка того, что все объекты в массиве мертвы. Я сам не знаю, как так получилось - это же невероятно просто. Это буквально стандартное решение, для которого даже думать не нужно!
А больше ничего интересного и не было. Хотя нет - я понял, что с моим "переключателем сцен" (который пока что просто включает/выключает объекты) нужно что-то делать. Сейчас это что-то жуткое, в котором наделать баги проще простого. Ну вы видели в предыдущей части, что у меня там. А сейчас туда добавился экран выбора героев и экраны победы с поражением.
Штош, на этом все. Хах, ладно. Обещал сделать прокачку герев - будет прокачка героев.
### Это же значит, что теперь я не обманываю читателей!
И вот тут столкнулся с неожиданной трудностью. По изначальному плану к этому моменту у меня все герои уже должны знать о том, какие характеристики на каких уровнях они будут иметь. Но этап с подтягиванием данных я ведь отложил. Значит, мне нужно сделать что-то, в чем будут храниться нужные мне данные.
И я решил не париться от слова “совсем”. Это решение наверняка плохое, но в дальнейшем я, скорее всего, от него избавлюсь. А пока… Решил использовать struct. Первый struct хранит характеристики на первом уровне. Второй - на сотом. Все значения между ними по задумке будут высчитываться интерполяцией.
Почему не сделать грамотно (например, сделав на устройстве файлик с этими значениями и подтягивать из него)? А все просто - еще не время разбираться в этом (ну и мне лень, чего уж там). Опять же - в дальнейшем struct наверное пропадет, а эти же данные будут подтягиваться из таблиц.
### План определен - поехали
И тут же останавливаемся. Оказалось, что текущая система данных в таблице неудачная - часть показывает характеристики на первом уровне, а часть - какими должны быть характеристики для достижения последнего уровня. Если проще - показывают характеристики на предпоследнем уровне.
Делаю колдунство с таблицей - и все вроде как нормально.
Нужно разобраться, что мне вообще делать:
* Получить список характеристик (как раз struct подготовил)
* Сделать так, чтобы за битву давали опыт в зависимости от противников
* Повышать в зависимости от полученного опыта уровень героя
* И находить соответствующие уровню характеристики
#### Для первого пункта делаю вот так
```
private void AddHeroLvlStats()
{
Level level1 = new Level(1, 1, 150, 100, 999, 100, 20, 10);
_heroLevelStats.Add(level1);
Level level150 = new Level(2, 150, 200, 100, 100, 10000, 40, 30);
_heroLevelStats.Add(level150);
Level level200 = new Level(3, 200, 200, 100, 100, 15000, 80, 90);
_heroLevelStats.Add(level200);
}
```
О том, что сделать это можно через for, подумал почему-то только что. А, и магические числа, да. Но у меня есть половинка оправдания! В дальнейшем вместо них будут поступать данные с таблицы. Хотя и сейчас можно к этому все подготовить))
#### Пункт 2
Внезапно стало легко определить, сколько опыта выдавать героям игрока - просто перемножаем количество опыта за противника на число противников:
```
private void IncTotalExp()
{
for (int i = _battleStarterScript.ActiveEnemies.Count - 1; i >= 0; i--)
{
_totalExpGained += _battleStarterScript.ActiveEnemies[i].GetComponent().Exp\_gain;
}
int howManyLvls = \_totalExpGained / \_battleStarterScript.ActiveHeroes[0].GetComponent().Exp\_Max;
float divi = \_totalExpGained % \_battleStarterScript.ActiveHeroes[0].GetComponent().Exp\_Max;
int newLevel = \_battleStarterScript.ActiveHeroes[0].GetComponent().Lvl\_Cur + howManyLvls;
int newCurExp = \_battleStarterScript.ActiveHeroes[0].GetComponent().Exp\_Cur + (int)divi;
foreach (GameObject hero in \_battleStarterScript.ActiveHeroes)
{
hero.GetComponent().SetNewLvl(newLevel);
hero.GetComponent().Exp\_Cur = newCurExp;
}
}
```
По поводу for... Честно - понятия не имею, почему при стандартном i++ у меня остается один активный объект.
#### Операция "Повышение"
Ой, а я же уже показал. Вычисляется, сколько уровней герой может получить в зависимости от полученного опыта. Затем уровень присваивается, а оставшийся остаток от деления становится "текущим опытом". Интересна тут функция hero.GetComponent().SetNewLvl(newLevel);, которая приводит нас к...
#### Свободная касса!
Итак - проблема. Мне известен набор характеристик на первом уровне героя. Известен набор характеристик на 150 уровне героя. А тут, внезапно, понадобилось узнать параметры героя на условном 38 уровне. Как это сделать?
Можно попробовать через for. Это будет чуть проще, чем через if или switch. Но, хоть я тот еще извращенец, к таким подвигам не готов. Зная пограничные значения, можно высчитать то, какие значения будут в любом месте между границами. Не буду томить - мне подсказали вот такую замечательную формулу:
```
public int GetStatsFromLvl(int lvl, List listLevels, int first, int last, Stats stat)
{
float a = listLevels[first].Lvl\_Max + ((float)listLevels[last].Lvl\_Max - (float)listLevels[first].Lvl\_Max) /
((float)listLevels[last].Lvl - 1) \* (lvl - 1);
return (int) a;
}
```
Функцию придумал уже я - и она 100% поменяется. Мне крайне не нравится, что приходится вручную указывать пограничные для значения структуры.
Ах да, думаю, вы уже успели отдохнуть от надругательства над беднягой c#. Не переживайте, подергивающийся глаз от встреченного Stats stat вас не обманул - это именно то, о чем вы подумали:
```
public int GetStatsFromLvl(int lvl, List listLevels, int first, int last, Stats stat)
{
float a;
switch (stat)
{
case Stats.Level\_Max:
a = listLevels[first].Lvl\_Max + ((float)listLevels[last].Lvl\_Max - (float)listLevels[first].Lvl\_Max) /
((float)listLevels[last].Lvl - 1) \* (lvl - 1);
break;
case Stats.Exp\_Max:
a = listLevels[first].Exp\_Max + ((float)listLevels[last].Exp\_Max - (float)listLevels[first].Exp\_Max) /
((float)listLevels[last].Lvl - 1) \* (lvl - 1);
break;
//
```
И так на каждый параметр. Я так и не придумал, как избавится от сравнения (хотя на 100% уверен, что можно).
Зато гляньте, какое чудо получается!
Магия! Это все больше и больше становится похоже на игру! Ну разве не чудо?
### Заключение
Это часть получилась довольно тяжелой, зато сделал целых три пункта из запланированного. Возникало невероятное количество проблем - порой на ровном месте. Зато было довольно весело. Но теперь мне нужно отдохнуть от кода. Изначально минимально рабочую версию собирался сделать до февраля, но сейчас начинаю сильно сомневаться, что успею. С продолжением вернусь уже в следующем году, так что с наступающим - и не скучайте!
И напишите, как вам эта часть! В предыдущей было много кода, но из-за того, что он был разбросан повсюду, читать было сильно скучно. Тут попытался сделать иначе. Как больше нравится - когда текст пишется по ходу событий или больше по итогу всего?
И я тут подумал... Вам не кажется, что битва квадратов с кружочками - это совсем не серьезно?
 | https://habr.com/ru/post/597819/ | null | ru | null |
# Js, трюки, наблюдения, бенчмарки и как Лиса уничтожает Хром. Я протестировал всё, что вам было лень
[](https://habr.com/ru/company/ruvds/blog/712386/)*Картинка, конечно, стронгли анрилейтед*
Разные трюки я тестировал на Google Chrome 107.0.5304.107 и Mozilla Firefox 107.0 на Windows 10.
Чтобы результаты всегда были железно воспроизводимыми, я отключил все С-State’ы, ядра зафиксировал на 5 ГГц.
У меня 9900К, это Coffee Lake c AVX256, какие оптимизации применит Jit для вашего процессора — я не знаю, результат на вашем компьютере может отличаться от моего, в т.ч. из-за микроархитектуры процессора.
Скорость парсинга кода тоже входит в бенчмарк, поэтому браузер с быстрым парсером будет впереди.
Есть ли у переменной оверхед?
-----------------------------
Есть ли смысл использовать только dot notation? Какова цена выноса лишней переменной?
```
var array = new Array(65535).fill()
// 3
var a = array.map((x) => x)
var b = array.map((x) => x)
var c = array.map((x) => x)
// 2
var a = array.map((x) => x)
var b = array.map((x) => x).map((x) => x)
// 1
var a = array.map((x) => x).map((x) => x).map((x) => x)
```
Чтобы узнать, гоняет ли браузер память туда-сюда, делаем мы `.map` на массив длиной 65535 с нулями внутри. [Линк](https://www.measurethat.net/Benchmarks/Show/22097/0/1-var-vs-2-vars-vs-3-vars).
*Здесь и далее в качестве единицы измерения на графиках будет указано кол-во выполнений кода в секунду, включая парсинг и компиляцию. Больше — лучше*
Хром не заметил разницы, а вот лиса заметила. Применительно к лисе, у лишней переменной есть измеряемый оверхед.
Есть ли разница между var, let, const или их отсутствием?
---------------------------------------------------------
Проверим. Используя разные биндинги — создадим POJO с переменной `е`. Потом добавим ему функцию `о` и запустим эту функцию. Бенчмарк простой, но движущихся частей много. [Линк](https://www.measurethat.net/Benchmarks/Show/22083/0/const-vs-let-vs-var-vs-sloppy).
```
var g = { e: [] }
g.o = function(x) { g.e.push(...[1,2,3]) }
g.o()
```
Код выглядит так, отличаются только биндинги.
Результат неожиданный, но железно воспроизводимый. `var`, быстрее.
Bounce pattern, Switch case, длинная тернарка
---------------------------------------------
Если обе конструкции логически одинаковые, они должны строить одно и то же синтаксическое дерево, верно? Давайте проверим.
```
// switch case
function thing(e) {
switch (e) {
case 0:
return "0";
case 1:
return "1";
case 2:
return "2";
case 3:
return "3";
default:
return "";
}
}
// bounce pattern
function bounce(x)
{
if (x === 0) return "0";
if (x === 1) return "1";
if (x === 2) return "2";
if (x === 3) return "3";
return ""
}
// ternary
function bounce(x) {
return 0 === x ? "0" : 1 === x ? "1" : 2 === x ? "2" : 3 === x ? "3" : "";
}
```
Вот так выглядит код. Для всех вариантов он одинаков, отличаются только вызовы.
### ▍ 1. Вызов в цикле
```
for (let t = 0; 1e5 > t; t++) bounce(0), bounce(2), bounce(6);
```
Вызов выглядит так. [Линк](https://www.measurethat.net/Benchmarks/Show/22099/0/no-type-coercion-switch-case-vs-bounce-pattern-vs-terna).
### ▍ 2. В цикле с другим типом
```
for (let t = 0; 1e5 > t; t++) bounce("0"), bounce("2"), bounce("");
```
Тут мы покидываем строку вместо числа. В свитче и `if` блоках используется строгое равенство, поэтому свитч выходит только через `default`, а `if`’ы выходят только последний `return`. [Линк](https://www.measurethat.net/Benchmarks/Show/22098/0/type-coercion-switch-case-vs-bounce-pattern-vs-ternary).
### ▍ 3. Без цикла
```
bounce(0), bounce(2), bounce(6)
```
Просто три вызова подряд, никаких циклов. [Линк](https://www.measurethat.net/Benchmarks/Show/22100/0/no-loop-switch-case-vs-bounce-pattern-vs-ternary).
Похоже, что после первоначальной компиляции лиса не пытается дальше оптимизировать цикл, как это делает хром.
Также лиса, похоже, не строит одно и то же AST, как это делает хром. Рекомендую заменить ваши длинные `if`’ы и bounce паттерны на свитчи, чтобы избежать лисиных тормозов.
Инициализация массива
---------------------
Для примера возьму из паттернов функционального программирования, когда ты инициализируешь массив, прокидывая лямбду в инициализатор. Просто ради примера, в качестве этой лямбды будет fizzbuzz.
```
var times = 65535;
function initializer(val, z) {
const i = z % 5 | 0;
return 0 == (z % 3 | 0) ? 0 === i ? "fizzbuzz" : "fizz" : 0 === i ? "buzz" : z;
}
// for i
var b = new Array(times);
for (var i = 0; i < times; i++) {
b[i] = initializer(b[i], i)
}
b
// for push
var c = [];
for (var i = 0; i < times; i++) {
c.push(initializer(c[i], i))
}
c
// Fill Map
new Array(times).fill().map(initializer)
```
Это не самый красивый fizzbuzz, но это мой fizzbuzz. [Линк на бенч](https://www.measurethat.net/Benchmarks/Show/22086/0/array-initialization-for-for-push-fill-map).
Вариант с `fill map` создаёт два массива, сначала при вызове конструктора, потом при вызове map. Но такой вариант безальтернативно быстрее на хроме.
Конкатенация массивов
---------------------
```
// reduce
arr.reduce((acc, val) => acc.concat(val), [])
// flatMap
arr.flatMap(x => x)
// flat
arr.flat()
// reduce push
arr.reduce((acc, val) => {
if (val) val.forEach(a => acc.push(a));
return acc;
}, [])
// forEach push
let acc = [];
arr.forEach(val => {
val && val.forEach(v => acc.push(v));
}), acc;
//concat spread
[].concat(...arr)
```
Конкатенация массивов на 1 уровень, поведение идентичное `flat(1)`. [Линк](https://www.measurethat.net/Benchmarks/Show/22085/0/flat-vs-flatmap-vs-reduce-vs-reduce-push-vs-foreach-pus).
Иногда я не понимаю, почему разработчики движков оставили такой потенциал для оптимизации.
Уничтожение хрома
-----------------
Бенчмарки ниже я перепроверял по нескольку раз, результат одинаковый и верный. Лиса действительно такая быстрая.
### ▍ Итерация по массиву
Сравнивать будем `Array.prototype.forEach vs for...of vs for`. На код смотрите [по линку](https://www.measurethat.net/Benchmarks/Show/22095/0/side-effect-for-i-vs-for-of-vs-foreach-fix).
Ради производительности, циклы `for`, лучше переделать в `forEach`, чтобы хром не отставал.
### ▍ Содержит ли строка значение
```
// text.includes()
url.includes('matchthis')
// text.test()
/matchthis/.test(url)
// text.match()
url.match(/matchthis/).length >= 0
// text.indexOf()
url.indexOf('matchthis') >= 0
// text.search()
url.search('matchthis') >= 0
```
Трюк с `IndexOf` быстрее и на лисе, и на хроме. Используйте трюк с `IndexOf`. [Линк на бенчмарк](https://www.measurethat.net/Benchmarks/Show/22090/0/includes-vs-test-vs-match-vs-indexof-vs-search-fix).
Преобразование строки в число
-----------------------------
Тестируем неявное преобразование, парсинг и вызов конструктора.
```
// implicit
var imp = + strNum
// parseFloat
var toStr = parseFloat(strNum)
//Number
var num = Number(strNum)
```
### ▍ Int
[Линк на бенч](https://www.measurethat.net/Benchmarks/Show/21897/0/implicit-vs-parseint-vs-number-string-to-num).
### ▍ Float
Я перепроверял, это не ошибка. Неявный каст стринги в инт практически бесплатный у лисы. [Линк на бенч](https://www.measurethat.net/Benchmarks/Show/22092/0/implicit-vs-parsefloat-vs-number-string-to-num).
Выводы
------
1. Лисичка похорошела.
2. JS сделан за неделю на коленке.
3. Я не пишу на JS.
4. Вы тоже прекращайте.
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=programmerguru&utm_content=js_tryuki_nablyudeniya_benchmarki_i_kak_lisa_unichtozhaet_xrom_ya_protestiroval_vsyo_chto_vam_bylo_len) | https://habr.com/ru/post/712386/ | null | ru | null |
# Selenium для Python. Глава 6. Объекты Страницы
Продолжение перевода неофициальной документации Selenium для Python.
Оригинал можно найти [здесь](http://selenium-python.readthedocs.org/page-objects.html).
Содержание:
-----------
1. [Установка](http://habrahabr.ru/post/248559/)
2. [Первые шаги](http://habrahabr.ru/post/250921/)
3. [Навигация](http://habrahabr.ru/post/250947/)
4. [Поиск элементов](http://habrahabr.ru/post/250975/)
5. [Ожидания](http://habrahabr.ru/post/273089/)
6. Объекты Страницы
7. WebDriver API
8. Приложение: Часто Задаваемые Вопросы
6. Объекты страницы
-------------------
Этот раздел является введением в руководство по паттернам проектирования объектов страницы. Объект страницы представляет собой область пользовательского интерфейса в веб-приложении, с которой будет взаимодействовать ваш тест.
Плюсы использования паттернов объектов страницы:
* Создание многократно используемого кода, который может быть использован среди множества тест-кейсов
* Уменьшение количества дублируемого кода
* Если интерфейс пользователя изменяется, требуется правка всего в одном месте
6.1 Тест-кейс
-------------
Ниже приведен тест-кейс, который ищет слово на python.org и показывает, что некий результат найден.
```
import unittest
from selenium import webdriver
import page
class PythonOrgSearch(unittest.TestCase):
"""A sample test class to show how page object works"""
def setUp(self):
self.driver = webdriver.Firefox()
self.driver.get("http://www.python.org")
def test_search_in_python_org(self):
"""
Tests python.org search feature. Searches for the word "pycon" then verified that some results show up.
Note that it does not look for any particular text in search results page. This test verifies that
the results were not empty.
"""
#Load the main page. In this case the home page of Python.og.
main_page = page.MainPage(self.driver)
#Checks if the word "Python" is in title
assert main_page.is_title_matches(), "python.org title doesn't match."
#Sets the text of search textbox to "pycon"
main_page.search_text_element = "pycon"
main_page.click_go_button()
search_results_page = page.SearchResultsPage(self.driver)
#Verifies that the results page is not empty
assert search_results_page.is_results_found(), "No results found."
def tearDown(self):
self.driver.close()
if __name__ == "__main__":
unittest.main()
```
6.2 Классы объекта страницы
---------------------------
Паттерн объекта страницы намеревается создать объект для каждой веб-страницы. Следуя этой технике, создается слой разделения между тестовым кодом и технической реализацией.
page.py будет выглядеть примерно так:
```
from element import BasePageElement
from locators import MainPageLocators
class SearchTextElement(BasePageElement):
"""This class gets the search text from the specified locator"""
#The locator for search box where search string is entered
locator = 'q'
class BasePage(object):
"""Base class to initialize the base page that will be called from all pages"""
def __init__(self, driver):
self.driver = driver
class MainPage(BasePage):
"""Home page action methods come here. I.e. Python.org"""
#Declares a variable that will contain the retrieved text
search_text_element = SearchTextElement()
def is_title_matches(self):
"""Verifies that the hardcoded text "Python" appears in page title"""
return "Python" in self.driver.title
def click_go_button(self):
"""Triggers the search"""
element = self.driver.find_element(*MainPageLocators.GO_BUTTON)
element.click()
class SearchResultsPage(BasePage):
"""Search results page action methods come here"""
def is_results_found(self):
# Probably should search for this text in the specific page
# element, but as for now it works fine
return "No results found." not in self.driver.page_source
```
6.3 Элементы страницы
---------------------
element.py будет выглядеть следующим образом:
```
from selenium.webdriver.support.ui import WebDriverWait
class BasePageElement(object):
"""Base page class that is initialized on every page object class."""
def __set__(self, obj, value):
"""Sets the text to the value supplied"""
driver = obj.driver
WebDriverWait(driver, 100).until(
lambda driver: driver.find_element_by_name(self.locator))
driver.find_element_by_name(self.locator).send_keys(value)
def __get__(self, obj, owner):
"""Gets the text of the specified object"""
driver = obj.driver
WebDriverWait(driver, 100).until(
lambda driver: driver.find_element_by_name(self.locator))
element = driver.find_element_by_name(self.locator)
return element.get_attribute("value")
```
6.4 Локаторы
------------
Один из методов — это выделить строки локатора из места, где они будут использоваться. В этом примере локаторы на одной странице принадлежат одному классу.
locators.py будет выглядеть вот так:
```
from selenium.webdriver.common.by import By
class MainPageLocators(object):
"""A class for main page locators. All main page locators should come here"""
GO_BUTTON = (By.ID, 'submit')
class SearchResultsPageLocators(object):
"""A class for search results locators. All search results locators should come here"""
pass
``` | https://habr.com/ru/post/273115/ | null | ru | null |
# NVIDIA Jetson Nano: тесты и первые впечатления
Привет, Хабр.
Относительно недавно, в этом, 2019 году, NVIDIA [анонсировала одноплатный компьютер](https://habr.com/ru/post/444442/) совместимого с Raspberry Pi форм-фактора, ориентированный на AI и ресурсоемкие расчеты.
После его появления в продаже, стало интересно посмотреть, как это работает и что на нем можно делать. Стандартные бенчмарки использовать не так интересно, так что придумаем свои, для всех тестов в тексте приведены исходники. Для тех, кому интересно что получилось, продолжение под катом.
Hardware
--------
Для начала, технические характеристики с сайта NVIDIA:
Из интересного, здесь можно отметить несколько моментов.
Первое — это GPU, имеющий 128 ядер, соответственно, на плате можно запускать GPU-ориентированные задачи, вроде CUDA (поддерживается и установлен из «коробки») или Tensorflow. Основной процессор 4х ядерный, и как будет показано ниже, вполне неплохой. Память 4Гб, общая между CPU и GPU.
Второе — это совместимость с Raspberry Pi. Плата имеет 40-пиновый разъем с различными интерфейсами (I2C, SPI и пр), также имеется разъем камеры, который тоже совместим с Raspberry Pi. Можно предположить, что большое количество уже имеющихся аксессуаров (экраны, платы управления моторами и пр) будут работать (возможно, придется использовать удлиннительный кабель, т.к. Jetson Nano все же отличается по габаритам).
Третье — на плате имеется 2 видеовыхода, Gigabit-Ethernet и USB 3.0, т.е. Jetson Nano в целом даже чуть более функциональна чем «прообраз». Питание 5В, может браться как по Micro USB, так и через отдельный разъем, который рекомендуется для ~~майнинга биткоинов~~ ресурсоемких задач. Так же как и в Raspberry Pi, софт грузится с SD-карты, образ которой нужно предварительно записать. В целом, по идеологии, плата вполне похоже на Raspberry Pi, что видимо и задумывалось в NVIDIA. Но вот WiFi на плате нет, что есть определенный минус, желающим придется использовать USB-WiFi модуль.
Если присмотреться внимательно, то можно увидеть, что конструктивно устройство состоит из двух модулей — собственно модуля Jetson Nano, и нижней платы с коннекторами, соединение осуществляется через разъем.
Т.е. плату можно отсоединить и использовать отдельно, это может быть удобно для встраиваемых решений.
Кстати о цене. Оригинальная цена Jetson Nano в США 99$, цена в Европе с наценкой в местных магазинах порядка 130Евро (если ловить скидки, наверно можно найти и дешевле). Сколько стоит Nano в России, неизвестно.
Software
--------
Как упоминалось выше, загрузка и установка мало отличается от Raspberry Pi. Загружаем [образ](https://developer.nvidia.com/embedded/learn/get-started-jetson-nano-devkit#write) на SD-карту через Etcher или Win32DiskImager, попадаем в Linux, ставим необходимые библиотеки. Отличное по подробности пошаговое руководство есть [здесь](https://www.pyimagesearch.com/2019/05/06/getting-started-with-the-nvidia-jetson-nano/), я пользовался им. Перейдем сразу к тестам — попробуем запустить разные программы под Nano, и посмотрим как они работают. Для сравнения я использовал три компьютера — свой рабочий ноутбук (Core I7-6500U 2.5ГГц), Raspberry Pi 3B+ и Jetson Nano.
**Тест CPU**
Для начала, скриншот команды lscpu.
Raspberry Pi 3B+:
Jetson nano:
Для расчетов начнем с чего-нибудь простого, но требующего процессорного времени. Например, с вычисления числа Пи. Я взял несложную программу на Python со [stackoverflow](https://stackoverflow.com/questions/9004789/1000-digits-of-pi-in-python).
Не знаю, является ли она оптимальной или нет, но нам это и не важно — нам интересно *относительное время*.
**Исходный код под спойлером**
```
import time
# Source: https://stackoverflow.com/questions/9004789/1000-digits-of-pi-in-python
def make_pi():
q, r, t, k, m, x = 1, 0, 1, 1, 3, 3
for j in range(10000):
if 4 * q + r - t < m * t:
yield m
q, r, t, k, m, x = 10*q, 10*(r-m*t), t, k, (10*(3*q+r))//t - 10*m, x
else:
q, r, t, k, m, x = q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2
t1 = time.time()
pi_array = []
for i in make_pi():
pi_array.append(str(i))
pi_array = pi_array[:1] + ['.'] + pi_array[1:]
pi_array_str = "".join(pi_array)
print("PI:", pi_array_str)
print("dT:", time.time() - t1)
```
Как и ожидалось, программа работает не быстро. Результат для Jetson Nano: 0.8c.
Raspberry Pi 3B+ показал заметно большее время: 3.06c. «Образцовый» ноутбук выполнил задачу за 0.27с. В общем, даже без использования GPU, основной процессор в Nano вполне неплох для своего форм-фактора. Желающие могут проверить на Raspberry Pi 4, у меня ее в наличии нет.
Наверняка найдутся желающие написать в комментариях, что Python не лучший выбор для таких расчетов, еще раз повторюсь, что нам важно было *сравнить* время, необходимости его минимизировать здесь нет. Понятно, что есть программы, вычисляющие число Пи гораздо быстрее.
**PyCUDA**
Перейдем к более интересному, расчетам с помощью GPU, для чего разумеется (плата ведь от NVIDIA), будем использовать CUDA. Библиотека PyCUDA потребовала некоторого шаманства при установке, она не находила cuda.h, помогло использование команды «sudo env „PATH=$PATH“ pip install pycuda», возможно есть другой способ (еще варианты обсуждались [на форуме devtalk.nvidia.com](https://devtalk.nvidia.com/default/topic/1056369/pycuda-installation-failure-on-jetson-nano/)).
Для теста я взял несложную программу [SimpleSpeedTest](https://wiki.tiker.net/PyCuda/Examples/SimpleSpeedTest) для PyCUDA, которая просто в цикле считает синусы, ничего полезного такой тест не делает, но время оценить им вполне можно, и его код простой и понятный.
**Исходный код под спойлером**
```
# SimpleSpeedTest.py
# https://wiki.tiker.net/PyCuda/Examples/SimpleSpeedTest
import pycuda.driver as drv
import pycuda.autoinit
from pycuda.compiler import SourceModule
import numpy
import time
blocks = 64
block_size = 128
nbr_values = blocks * block_size
n_iter = 100000
print("Calculating %d iterations" % (n_iter))
print()
#####################
# SourceModule SECTION
# create two timers so we can speed-test each approach
start = drv.Event()
end = drv.Event()
mod = SourceModule("""__global__ void gpusin(float *dest, float *a, int n_iter)
{
const int i = blockDim.x*blockIdx.x + threadIdx.x;
for(int n = 0; n < n_iter; n++) {
a[i] = sin(a[i]);
}
dest[i] = a[i];
}""")
gpusin = mod.get_function("gpusin")
# create an array of 1s
a = numpy.ones(nbr_values).astype(numpy.float32)
# create a destination array that will receive the result
dest = numpy.zeros_like(a)
start.record() # start timing
gpusin(drv.Out(dest), drv.In(a), numpy.int32(n_iter), grid=(blocks,1), block=(block_size,1,1) )
end.record() # end timing
# calculate the run length
end.synchronize()
secs = start.time_till(end)*1e-3
print("PyCUDA time and first three results:")
print("%fs, %s" % (secs, str(dest[:3])))
print()
#############
# CPU SECTION
# use numpy the calculate the result on the CPU for reference
a = numpy.ones(nbr_values).astype(numpy.float32)
t1 = time.time()
for i in range(n_iter):
a = numpy.sin(a)
print("CPU time and first three results:")
print("%fs, %s" % (time.time() - t1, str(a[:3])))
```
Как можно видеть, вычисление делается с помощью GPU через CUDA и с помощью CPU, через numpy.
Результаты:
Jetson nano — 0.67c GPU, 13.3c CPU.
Raspberry Pi 3B+ — 41.85c CPU, GPU — данных нет, CUDA на RPi не работает.
Ноутбук — 0.05с GPU, 3.08c CPU.
Все вполне ожидаемо. Расчеты на GPU гораздо быстрее расчетов на CPU (все же 128 ядер), Raspberry Pi отстает весьма значительно. Ну и разумеется, ~~сколько волка не корми, у слона все равно больше~~ ноутбучная видеокарта гораздо быстрее карты в Jetson Nano — вполне вероятно, что вычислительных ядер в ней гораздо больше.
Заключение
----------
Как можно видеть, плата у NVIDIA получилась вполне интересной и весьма производительной. Она немного больше по размеру и дороже, чем Raspberry Pi, но если кому-то нужна б*о*льшая вычислительная мощность при компактном размере, то оно вполне стоит того. Разумеется, нужно это не всегда — чтобы например, отправлять температуру на narodmon, хватит и Raspberry Pi Zero, причем с многократным запасом. Так что Jetson Nano не претендует на *замену* Raspberry и клонов, но для ресурсоемких задач она весьма интересна (это могут быть не только дроны или мобильные роботы, но и например, [камера для дверного звонка](https://medium.com/@ageitgey/build-a-hardware-based-face-recognition-system-for-150-with-the-nvidia-jetson-nano-and-python-a25cb8c891fd) с распознаванием лиц).
В одну часть все задуманное не уместилось. Во второй части будут тесты AI-части — тесты Keras/Tensorflow и задач по классификации и распознаванию изображений. | https://habr.com/ru/post/460723/ | null | ru | null |
# Мультиклассовая классификация текста. Дисбаланс тренировочных данных и их генерация. Особенности взвешивания TF-IDF
Классификация текста количеством более двух меток одна из самых сложных задач в машинном обучение. Как, правило сырые данные перед обучением модели требуют серьёзной обработки.
*Впервые с подобной задачей я столкнулся на своей работе – было необходимо обработать текст обратной связи посетителей портала с ограниченным количеством символов - около ста слов – сообщения могли состоять как из одного слова, так и из нескольких предложений. Количество классов – пять, от очень плохой «эмоциональной окраски» сообщения до очень хорошей.*
Данные
------
*По причине NDA я не могу демонстрировать данные, которые предоставил клиент, поэтому специально для этой статьи я собрал собственный сет данных отзывов об отелях – стандартная история для классификации тональности.*
Мой «демонстрационный» сет данных содержит 163830 текстовых сообщений (желающие могут скачать по [ссылке](https://drive.google.com/file/d/13b57W8XKkaT5m_cEeumeGtpXhtQCrlyk/view?usp=sharing)), как и у данных клиента, в сете присутствует сильный дисбаланс в классах, что очень ощутимо сказывается на итоговой точности предсказания.
*На порядок меньше отзывов с метками* ***1 и 3****, и напротив крупный перевес представляет* ***5-ый класс****.*
Так же тексты весомо отличаются по своей длине, при средней длине отзыва 50 токенов присутствуют крупное кол-во, превышающее значения 100 токенов – встречаются тексты и более тысячи.
Тестовые данные для чистоты эксперимента я выделил в отдельный фрейм размером 25000 строк – по 5000 сообщений на каждый класс. Моделируя реальную задачу, в тестовый набор я добавлял только сообщения с количеством токенов от 1 до 100.
Задача
------
В этом исследование я хочу разобрать отдельный сегмент предобработки данных, а именно показать, насколько балансировка тренировочных данных может качественно повлиять на конечный результат, а также чуть глубже погрузиться в суть работы механизма взвешивания слов TF-IDF
Генерация данных
----------------
Первым делом определимся с необходимым количеством отзывов для каждого класса. Я посчитал что 30-35 тысяч отзывов будет оптимальным решением. Необходимо сгенерить 20к текстов для первого и для третьего класса, а 15 тысячами текстов для 5-го придётся пожертвовать.
Существует множество способов генерации текста, в том числе с применением различных библиотек, я же реализую наиболее «дешевый» с точки зрения времени вычисления вариант, основанный **на частоте использования биграмм** тренировочного корпуса. В данной задаче для нас **не имеет значение семантический аспект генерируемых предложений**, так для взвешивания токенов будет использоваться метод TF-IDF. Далее в статье я подробней остановлюсь на этом методе, а здесь оставлю мой вариант скрипта, генерирующего текст для первого класса (очень плохие отзывы).
Первым делом напишем функцию (*tokenize\_sentences*) разбиения текстов корпуса, которая возвращает список токенов, разделённых фиктивным токеном (*'END\_SENT\_START'*) в конце каждого предложения. *['начнем', 'с', 'того', 'что', 'в', 'этом', 'отеле', 'не', 'берут', 'деньги', 'только', 'за', 'воздух', 'END\_SENT\_START', 'звонок', 'с', 'телефона', ...]*
```
import pandas as pd
import numpy as np
import sklearn
import re
import nltk
from nltk import tokenize
from nltk.tokenize import RegexpTokenizer
def get_text_for_label(df, label): # Получим список с текстами для каждого класса
label = 'label == ' + str(label)
df_label = df.query(label).drop(['label'], axis=1)
return df_label.feedback.values.tolist()
feedback_label_1 = get_text_for_label(df_fin_feedback, 1) # К примеру, список для первого класса
def tokenize_sentences(text_corp): # Функцию разбиения текстов корпуса на токены с разбивкой по предложениям
token_corp = []
for text in text_corp:
text = re.sub(r'\s+', ' ', text, flags=re.M)
for sent in re.split(r'(?<=[.!?…])\s+', text):
sent = sent.replace('\n',' ')
for word in sent.split():
token = re.search(r'[а-яёА-ЯЁa-zA-Z]+', word, re.I)
if token is None:
continue
token_corp.append(token.group().lower())
token_corp.append('END_SENT_START') # В конце каждого предложения добавляем фиктивный токен
return token_corp
token_label_1 = tokenize_sentences(feedback_label_1) # К примеру, список для первого класса
```
На вход следующей функции поступает получившийся список токенов. Функция возвращает словарь с группированными биграммами: ключи – отдельные токены, в значение – список слов которые следуют за ними в корпусе с собственной частотой ( { 'отель': [('отличным', 4.116e-06), ('вобщем', 2.058e-06), …)
```
from collections import Counter, defaultdict
def get_bigramms(token_list):
bigramm_corp = []
for i in range(len(token_list)-1):
bigramm = token_list[i] + ' ' + token_list[i+1]
bigramm_corp.append(bigramm) # Получим список биграмм
unique_token_count = len(set(bigramm_corp)) # кол-во уникальных биграмм
bigramm_proba = {} # Создаю словарик для результата: Ключ - биграмма. Значение - вероятность
count_bigramm = Counter(bigramm_corp) # Создаю словарь для хранения частот биграмм
count_token = Counter(token_list) # Создаю словарь для хранения частот токенов
# Создаю словарь с группированными биграммами: ключи – отдельные токены,
# в значение – список слов которые следуют за ними в корпусе
# с собственной частотой ( { 'отель': [('отличным', 4.116e-06), ('вобщем', 2.058e-06), …)
grouped_bigramms = defaultdict(list)
for bigramm in set(bigramm_corp):
first_word, second_word = bigramm.split()
proba = (count_bigramm[bigramm] + 1) / (count_token[first_word] + unique_token_count) # Формула Лапласа
grouped_bigramms[first_word].append((second_word, proba))
return grouped_bigramms
grouped_bigramm_1 = get_bigramms(token_label_1) # На примере первого класса
```
Дальше код для самой генерации предложений. Скрипт выдаёт 4 предложения по 15 слов каждое, примерно следующего содержания :)
> *'советовали как и вся мебель в качестве вступления хочу от отеля не звонила на пользу выбора. округа говорит по часа видимо поэтому администрация обратит внимание что пробовать желания нет чайника ни сосисок. отнесен к сведенью, линию стали ждать пока мы были с сухариками, отфутболивают, вечерний рынок где то. чернышевской, привлекательными чем я уезжала из санатория а тут просто праздник но очень экономит особенно если.'*
>
>
```
import random
def generate_texts(token_label, grouped_bigramm, label, count_text, count_sent, count_word):
# Создаём словарь для подсчёта биграмм "исключений"
exceptions_bigramm = defaultdict(int)
# Создаём список уникальных токенов для старта предложения
unique_token = list(set(token_label))
texts = []
for it_text in range(count_text): # Цикл с диапазоном кол-ва текстов
text = ''
unique_word = set()
# Цикл с диапазоном кол-ва предложений в тексте
for it_sent in range(count_sent):
len_sent = count_word
# Генерим случайное слово для начала предложения для обеспечения стохастического процесса генерации предложения
start_word = random.choice(unique_token)
# Записываем в строку с финальным предложением первое стартовое слово
final_sent = start_word
# Множество уникальных слов, которые уже сгенерились в предложение (чтобы геенерация не зацикливалась)
unique_word.add(start_word)
for step in range(count_word):
next_word = None # Создаём переменную для нового слова
frequency = 0 # Переменная-счётчик для частоты каждого нового слова
# Проходим циклом по словарю с ключом биграммы и значением её частоты
for second_word, freq in grouped_bigramm[start_word]:
bigramm = start_word + ' ' + second_word
# Устанавливаем значение максимального повторения слова в одном тексте
if exceptions_bigramm[bigramm] > 3:
continue
if freq > frequency and second_word not in unique_word and second_word != 'END_SENT_START':
next_word = second_word
frequency = freq # Если второе слово проходит условие запоминаем его
if next_word is None: # Если подходящего по условиям слова не найдено, перезаписываем стартовое слово и начинаем поиск заново
start_word = random.choice(unique_token)
final_sent += ', ' + start_word
unique_word.add(start_word)
else:
# Если после цикла нашли подходящее слова (которое запомнили в цикле) - записываем его в предложение
exceptions_bigramm[start_word + ' ' + next_word] += 1
start_word = next_word
final_sent += ' ' + next_word
unique_word.add(start_word)
final_sent += '. '
text += final_sent
texts.append(text)
generation_text_df = pd.DataFrame(texts, columns=['feedback']) # Формируем фрейм из списка
generation_text_df['label'] = label
return generation_text_df[['label', 'feedback']]
label_1_df = generate_texts(token_label_1, grouped_bigramm_1, label=1, count_text=15000, count_sent=4, count_word=15)
```
Как, я упоминал ранее при данной задаче, для генерации **семантика не имеет принципиального значения, важней частота появления слова в корпусе** и именно на такой результат заточен алгоритм. И теперь, запамятовав вышесказанное, перейдём к следующей части работы.
Баланс данных
-------------
Сгенерировав недостающее количество текстов, следует привести к балансу длину самих текстов. *Для чего?* Что бы ответить на этот вопрос, вспомним как работает механизм взвешивания текста TF-IDF.
Мера TF-IDF является произведением двух сомножителей.
TF - частота слова - отношение числа вхождений некоторого слова к общему числу слов документа. Таким образом, оценивается важность слова в пределах отдельного документа.
IDF - обратная частота документа - инверсия частоты, с которой некоторое слово встречается в документах коллекции. Учёт IDF уменьшает вес широкоупотребительных слов. Для каждого уникального слова в пределах конкретной коллекции документов существует только одно значение IDF.
Большой вес в TF-IDF получат слова с высокой частотой **в пределах конкретного документа** и с низкой частотой употреблений **в других документах**. То есть, если мы имеем корпус с текстами с сильно различным количеством слов, мы рискуем получить завышенный показатель IDF если слово встречается только в маленьких текстах и наоборот если слово часто встречается много раз только в одном крупном тексте.
Ещё раз по-другому
* *Первый случай. Слово t встречается* ***пять раз в тексте длинной 500 слов****: знаменатель формулы IDF получит 1 бал и завысит показатель самого IDF, а следовательно, общий вес слова.*
* *Второй случай. Слово t встречается* ***по одному разу в пяти текстах длинной 100 слов****: знаменатель формулы IDF получит 5 балов и занизит показатель самого IDF, а следовательно, общий вес слова.*
Подводя черту, выходит, что, зная длину текстов тестовых данных, мы можем качественно повлиять на результат взвешивания слов, **корректируя длину текстов для тренировочных данных**. Если мы знаем, что в тестовой выборке сообщения длиной не более 100 слов, нам выгодней использовать веса, определённые во втором случае. Проверим гипотезу на практике
Приведём токены к их леммам
```
from nltk.tokenize import RegexpTokenizer
from nltk import tokenize
import nltk
import pymorphy2
morph = pymorphy2.MorphAnalyzer()
def lemmatize(text):
pattern = '[а-яёА-ЯЁ]+'
tok = tokenize.RegexpTokenizer(pattern)
text = tok.tokenize(text)
def normalize(word):
return morph.parse(word.lower())[0].normal_form
return " ".join([normalize(it) for it in text if len(it) > 2])
df_feedback_train['feedback'] = df_feedback_train['feedback'].apply(lambda value: lemmatize(value))
```
Пропустим наш корпус через функцию разбиения/склеивания текстов и получим новый корпус с длинами документов, в заданном тестовым набором, диапазонах – **от одного до ста токенов.**
В функцию передаются аргументы: *1. сам корпус; 2. нижний порог слов в тексте; 3. верхний порог слов; 4. нижний порог слов в текстах «под отсечение».*
```
list_feedback_label_1 = get_text_for_label(df_feedback_train, 1) # Снова получим список документов из фрейма (пример для первого класса)
def balance_text(corp, low_thresh, high_thresh, low_remove_tresh):
new_corp, temp = [], []
for text in corp:
if low_thresh <= len(text) <= high_thresh: # Если длина текста в пределах диапазона - оставляем текст без изменения
new_corp.append(text)
elif len(text) < low_thresh: # Если длина текста меньше нижнего порога - запоминаем, затем склеиваем с таким же текстом
if len(temp) >= low_thresh:
new_corp.append(temp)
temp = text
else:
temp.extend(text)
else:
# Если длина текста больше верхнего порога - сплитим на меньшие тексты в рамках диапазона
# Совсем мелкие хвостовые части не добавляем
for j in range(0, len(text) - low_remove_tresh, high_thresh):
new_corp.append(text[j:min(len(text), j + high_thresh)])
if len(temp) > low_remove_tresh:
new_corp.append(temp)
return new_corp
label_1_feedback_balance = balance_text(list_feedback_label_1, 50, 100, 10) # Получаем сбалансированный текст для первого класса
# Всё тоже проделываем для всех 5-ти классов.
```
В результате получим следующее распределение количества токенов в документах.
Здесь следует сделать отступление. Если взглянуть на аналогичный график распределения слов для первого класса тестовой выборе (график ниже), мы увидим картину идеального нормального распределения. Следовательно, и распределение для тренировочной выборки я стремился сделать схожим – нормальным, но именно нормальное распределение в тренировочной выборке дало худший показатель точности, а самый оптимальный представлен на графике выше.
Итак, мы получили корпуса со сбалансированным количеством слов, теперь отсечём лишнее – думаю 40к доков для каждого класса будет достаточно для демонстрации, затем обучим классификатор и сравним результат с результатами на разных этапах предобработки тренировочных данных. В связке с TF-IDF неплохо работает логистическая регрессия.
```
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns
# Отсекаем лишнее количество документов для выравнивания кол-ва текстов в представленных классов между собой
label_1_feedback_balance = label_1_feedback_balance[:40000] # Так для каждого класса
# Склеиваем один фрейм для тренировочных данных
def list_to_df(texts, label): # Функция для получения фрейма для каждого класса
feedback = [' '.join(it) for it in texts]
labels = [label for i in range(len(texts))]
return pd.DataFrame(list(zip(labels, feedback)), columns =['label', 'feedback'])
df_label_1 = list_to_df(label_1_feedback_balance, 1) # Так для каждого класса (получаем фрейм)
df_feedback_train_balance = pd.concat([df_label_1, df_label_2, df_label_3, df_label_4, df_label_5], axis=0) # Склеиваем
df_feedback_train_balance = df_feedback_train_balance.sample(frac=1).reset_index(drop=True) # Не забыть перемешать тексты
X_train_text = df_feedback_train_balance['feedback'].values
X_test_text = df_feedback_test['feedback'].values
y_train = df_feedback_train_balance['label'].values
y_test = df_feedback_test['label'].values
v = TfidfVectorizer(norm=None, max_df=0.8, max_features=500, decode_error='replace') # Взвешиваем вектора
X_train_vector = v.fit_transform(X_train_text)
X_test_vector = v.transform(X_test_text)
clf = LogisticRegression( random_state=64, solver='lbfgs', max_iter=10000, n_jobs=-1) # Обучаем классификатор
clf.fit(X_train_vector, y_train)
y_pred = clf.predict(X_test_vector)
# Вывод результатов
print(accuracy_score(y_test, y_pred))
print(classification_report(y_test,y_pred))
T5_lables = ['5','4','3','2','1']
ax= plt.subplot()
cmm = confusion_matrix(y_test,y_pred)
sns.heatmap(cmm, annot=True, fmt='g', ax=ax);
ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels');
ax.set_title('Confusion Matrix');
ax.xaxis.set_ticklabels(T5_lables); ax.yaxis.set_ticklabels(T5_lables);
```
Модель с загруженными начальными данными (не прошедшими предобработку) показала точность **0.51211**. Классы сильно разбалансированы, это хорошо просматривается в показателях precision и recall.
Модель с добавлением сгенерированных данных в слабо представленных классах дала результат точности предсказания в **0,56897**.
Модель же с добавлением сгенерированных данных и балансировкой текстов по длине показала точность **0,64984**. Уточнённые показатели так же выглядят приятней, да и прирост в точности в **8%** при многоклассовой классификации довольно ощутимый результат.
Спасибо за внимание!
Буду рад Вашим замечанием, с удовольствием отвечу на вопросы в комментариях. | https://habr.com/ru/post/677512/ | null | ru | null |
# Архитектура первой PlayStation: центральный процессор
Краткое введение
----------------
Sony знала, что разработка для 3D-оборудования может становиться очень сложной. Поэтому в дизайне своей первой консоли она стремилась к *простоте* и *практичности*… Однако всё имеет свою цену!
---
CPU
---
В этом разделе мы проанализируем Sony CXD8530BQ — один из двух больших чипов, содержащихся в консоли. Сегодня мы бы назвали его «System-on-Chip».
### Происхождение
Сюжет о создании процессора в виде «X спроектирован компанией Y на основе Z при поддержке W» сложно будет рассказать в нескольких предложениях, поэтому почему бы начать с исторического контекста?
**Фотографии и схемы консоли**
### Модели
*Оригинальная PlayStation. Выпущена 03.12.1994 в Японии, 09.09.1995 в Северной Америке, 29.09.1995 в Европе.*
*PS One (slim-версия). Выпущена 07.07.2000 в Японии, 19.09.2000 в Северной Америке, 29.09.2000 в Европе. Вот что можно получить, засунув кучу специализированных интегральных схем в одну.*
### Материнские платы
*Материнская плата модели «SCPH-1000». Остальные чипы расположены на обратной стороне. В более поздних моделях вместо VRAM использовалась SG-RAM и были убраны многие внешние разъёмы ввода-вывода и вывода видео.*
*Важные части материнской платы*
### Схема
*Схема основной архитектуры. Блок шинного интерфейса (Bus Interface Unit) также подключен к специальным портам GPU и SPU.*
#### Немного истории
Начало девяностых ознаменовалось сменой судьбы многих популярных CPU. Когда-то бывшие ведущими 8-битные процессоры, например, [Z80](https://www.copetti.org/writings/consoles/master-system/#cpu) и [6502](https://www.copetti.org/writings/consoles/nes/#cpu), уже ушли из света рамп, а знаменитый [68000](https://www.copetti.org/writings/consoles/mega-drive-genesis/#cpu) компании Motorola, наряду с другими [16-битными архитектурами](https://www.copetti.org/writings/consoles/super-nintendo/#cpu), купавшимися в успехе в конце 80-х, стали кандидатами на выбывание. В те времена в журнале PC World Таненбаум в своём знаменитом споре с Торвальдсом даже давал архитектуре x86 компании Intel *всего пять лет*, прежде чем она покинет рынок домашних систем.
Поначалу может показаться, что технологическое развитие в тот момент зашло в тупик. Но в реальности возникла новая волна относительно неизвестных CPU, пробивающих себе дорогу в мейнстримные устройства. Многие из этих архитектур вышли из научных кругов, то есть существовали только в качестве доказательства жизнеспособности неких архитектурных идей. В то время примерами CPU нового поколения были следующие архитектуры:
* **MIPS**: использовалась Silicon Graphics Incorporated (в графических рабочих станциях).
* **PowerPC**: использовалась Apple (в области компьютерной вёрстки).
* **SPARC**: создана Sun Microsystems (предназначена для серверов и рабочих станций бизнес-класса).
* **ARM**: создана Acorn (предназначена для потребительского рынка и рабочих станций).
Все эти процессоры имели нечто общее: все они использовали схему **Reduced Instruction Set Computer** (RISC), что радикально меняло способ их проектирования и программирования. Одно из правил процессоров RISC гласило, что одна команда не может смешивать память с операциями с регистрами, что позволяло проектировщикам оборудования упростить выполняющие команды электрические схемы и дополнить их техниками параллельной обработки.
#### MIPS и Sony
В конце 80-х, после того, как Silicon Graphics Incorporated (SGI) начала использовать процессоры MIPS в своём оборудовании, они стали темой активного обсуждения. SGI была влиятельным инноватором на рынке компьютерной графики, особенно благодаря разработке [конвейеров обработки вершин с аппаратным ускорением](https://www.copetti.org/writings/consoles/nintendo-64/#graphics), задачу которых изначально выполняло ПО (внутри CPU).
На момент разработки PlayStation компания MIPS продавала серию процессоров **R3000A**. Это были 32-битные машины из недорогого класса продукции компании. То есть R3000A не были частью флагманской линейки (в отличие от R4000, который позже выберут [другие производители](https://www.copetti.org/writings/consoles/nintendo-64/#cpu)), но являлись привлекательной инвестицией с точки зрения цены.
Свои звуковой и графический чипы Sony проектировала самостоятельно, но ей всё равно нужен был ведущий чип, способный управлять этими двумя. Выбранный CPU должен быть стать достаточно мощным, чтобы продемонстрировать *впечатляющие* возможности чипов Sony, но в то же время доступным по цене, чтобы сохранить конкурентоспособность консоли.
#### LSI и контракт на производство
В то же время производитель полупроводниковых устройств **LSI Logic** предлагал бизнесам программу «создай свой собственный CPU». Эта услуга называлась **CoreWare**, она позволяла клиентам собирать собственные комплекты CPU из набора строительных блоков. В библиотеку CoreWare входил и блок CW33300 — ядро CPU на основе LSI LR33300 (чипа CPU, продававшегося компанией серийно).
К чему же я всё это рассказываю? Оказалось, что LSI LR33300 и CW33300 являются **двоично совместимыми версиями семейства MIPS R3000A**. Их архитектуры в определённых аспектах отличались, но интерфейс программирования (MIPS I ISA) оставался тем же.
В конечном итоге, Sony поручила LSI создать комплект CPU. Компания выбрала CW33000, изменила некоторые его части и скомбинировала с другими блоками, создав чип, который мы можем увидеть на материнской плате PlayStation.
### Предложение
Получившееся ядро CPU работает с частотой **33,87 МГц** и обладает следующими особенностями:
* **MIPS I** ISA (архитектура набора команд): первая версия набора команд MIPS. Среди прочих аспектов архитектуры 32-битная длина слова и наличие в наборе команд умножения и деления.
* **32 регистра общего назначения** и **2 регистра умножения/деления**: они тоже являются 32-битными. Один регистр общего назначения всегда имеет нулевое значение (R0), что стандартно для процессоров RISC.
* **32-битная шина данных**: в PS1 шина данных разветвляется на две шины.
+ **Основная шина (Main Bus)** (32-битная) → соединяется с основным ОЗУ, MDEC и GPU.
+ **Подчинённая шина (Sub Bus)** (16/8-битная) → соединяется с остальными чипами и вводом-выводом. Эта шина образует мост с **Bus Interface Unit**, что также обеспечивает доступ к специальным портам GPU и SPU.
* **32-битная адресная шина**: возможна адресация до 4 ГБ физической памяти (например, ОЗУ, ввод-вывод с отображением в память и т. п.).
* **5-этапный конвейер**: одновременное выполнение до пяти команд (подробное объяснение можно найти в [предыдущей статье](https://www.copetti.org/writings/consoles/sega-saturn/#cpu)).
* **4 КБ кэша команд**: его тоже можно «изолировать», что позволяет непосредственно манипулировать кэшем команд.
+ Как ни странно, **кэша данных нет**. **1 КБ памяти**, обычно используемый для кэша данных, отображён на фиксированный адрес. Эта область также называется **Scratchpad** (быстрая SRAM).
Чтобы обеспечить достаточные ресурсы, Sony выделила для общего использования **2 МБ ОЗУ**. Любопытно, что компания установила на материнскую плату чипы **Extended Data Out** (EDO). Они чуть более эффективнее обычной DRAM и обеспечивают меньшие задержки.
### Перехват управления у CPU
В определённые моменты одной из подсистем (графика, звук или CD) могут с высокой частотой требоваться большие блоки данных. Однако CPU не всегда способен справиться с такими запросами.
По этой причине контроллер CD-ROM, MDEC, GPU, SPU и параллельный порт при необходимости имеют доступ к **DMA-контроллеру**. DMA берёт на себя управление основной шиной и выполняет передачу данных. Получающаяся частота передачи намного выше, чем при использовании CPU, однако последний всё равно необходим для подготовки DMA-передачи.
Также стоит помнить о том, что при срабатывании DMA процессор не может получить доступа к основной шине. Это значит, что CPU будет простаивать, если только для него нет работы в Scratchpad!
### Дополнения к ядру
Как и другие CPU на основе MIPS R3000, CW33000 поддерживает конфигурации с четырьмя сопроцессорами. Sony решила использовать три:
#### System Control Coprocessor
**System Control Coprocessor** (сопроцессор управления системой), обозначенный как CP0, является стандартным блоком CPU MIPS. В системах на основе R3000 сопроцессор CP0 управляет реализацией кэша. То есть он обеспечивает прямой доступ к кэшу данных (имеющему форму «Scratchpad») и к кэшу команд (при помощи «изоляции кэша»). Управляющий сопроцессор также отвечает за обработку прерываний, исключений и контрольных точек (последнее полезно при отладке).
> Постойте, но разве сопроцессоры не должны только *расширять* функции CPU? Почему CP0 так тесно связан с CPU?
И в самом деле, ядра R3000 применяют сопроцессор управления системой, чтобы иметь возможность использовать многие его компоненты, однако вопрос «законности» этого сводится к интерпретации слова «сопроцессор». По мнению MIPS, сопроцессор не является строго дополнительной частью CPU, он также может управлять окружением CPU (кэшем, прерываниями и т. п.). Следовательно, сопроцессор может быть неотъемлемой частью системы. Об этом стоит помнить, когда мы говорим о системах, связанных с MIPS.
Позже в [системах на основе R4000](https://www.copetti.org/writings/consoles/nintendo-64/) в этот блок были включены Memory Management Unit (MMU) и Translation Lookaside Buffer (TLB), что расширило его возможности и позволило выполнять [новые роли](https://www.copetti.org/writings/consoles/nintendo-64/#memory-management).
#### Geometry Transformation Engine
CP2, или **Geometry Transformation Engine** (GTE) — это специальный математический сопроцессор, ускоряющий векторные и матричные вычисления.
Хоть сопроцессор и работает только с типами с фиксированной запятой, он обеспечивает полезные для 3D-графики операции:
* Матричное или векторное умножение и сложение; векторный квадрат.
* Перспективное преобразование (используется для 3D-проецирования).
* Внешнее произведение двух или трёх векторов (последнее используется для усечения).
* Множество функций интерполяции с использованием различных параметров.
* Depth Cueing и значение цвета от источника освещения (используются для операций с освещением и цветом).
* Среднее значение Z/глубины (подозреваю, что это нужно для «таблицы упорядочивания»; подробнее см. в разделе «Графика»).
Но вам не нужно это всё запоминать до конца статьи! Просто помните, что GTE занимается первыми этапами графического конвейера, например, 3D-проецированием, освещением и усечением. Это помогает в генерации данных, которые передаются GPU для рендеринга.
#### Motion Decoder
**Motion Decoder**, также называемый MDEC или Macroblock Decoder — это ещё один процессор, расположенный рядом с CPU. Он разжимает «макроблоки» в формат, понятный GPU. Макроблок (Macroblock) — это структура данных, содержащая изображение с похожим на JPEG кодированием.
За раз MDEC распаковывает битовые карты, состоящие из 8x8 пикселей с глубиной цвета 24 бита на пиксель. В руководстве по программированию Уокера утверждается, что MDEC может вычислить 9000 макроблоков в секунду. Это позволяет обеспечивать потоковую передачу **full-motion video** (FMV) в разрешении 320x240 с частотой 30 кадров в секунду.
Для передачи сжатых данных по пути CD-ROM → RAM → MDEC используется DMA. Тот же путь данные проделывают в обратном направлении, однако в этом случае пунктом назначения является VRAM.
Хотя этот компонент находится внутри SoC и использует ту же шину данных, это не сопроцессор MIPS, поэтому CPU/DMA получают к нему доступ через отображение в память (а не при помощи перехвата команд).
Более подробную информацию об устройстве MDEC я рекомендую поискать на ресурсах Сабина и Чекански (см. раздел «Источники»).
### Пропавшие устройства?
Пока мы рассматривали CP0 и CP2, но **где же CP1**? Это обозначение зарезервировано для **Floating Point Unit** (FPU, сопроцессора для чисел с плавающей точкой), а Sony, к сожалению не использовала его. Это не значит, что CPU не может выполнять арифметические действия с десятичными числами, они просто выполняются не очень быстро (эмулируемый программно FPU) и точно (вычисления с фиксированной запятой).
Игровая логика (включающая в себя физику, распознавание коллизий и т. п.) может обойтись и вычислениями с фиксированной запятой. Кодирование с фиксированной запятой хранит десятичные числа с неизменным количеством десятичных разрядов. Это подразумевает потерю точности после некоторых операций, но стоит помнить, что это видеоигровая консоль, а не профессиональный лётный симулятор. Поэтому компромисс между точностью и производительностью вполне приемлем.
Кстати, иногда я путаю понятия «фиксированной запятой», «плавающей запятой», «десятичного» и «целочисленного» типа чисел (надеюсь, этого больше не повторится!). Если у вас та же проблема, то рекомендую изучить краткое объяснение Габриеля Иванческу (см. раздел «Источники»).
### Куча задержек
Как мы видели ранее, CW33300 — это конвейерный процессор, то есть он объединяет множество команд в очередь и выполняет их параллельно на разных этапах. Это значительно повышает скорость обработки команд, но без должного контроля это может привести к **конфликтам конвейера**, вызывающим ошибки вычислений.
Архитектура MIPS I подвержена **конфликтам управления** и **конфликтам данных**, то есть команды могут выполняться не тогда, когда нужно, и оперировать с устаревшими данными до их обновления.
*Команды из Spyro The Dragon, визуализированные в отладчике NO$PSX. Обратите внимание, что за командами `LW` (load word from memory), `JAL` (jump and link) и `BAL` (branch on not equal) следует слот задержки для предотвращения конфликтов. Красным отмечены заполнители (бесполезные команды). Синим отмечены существенные операции.*
Следовательно, процессоры MIPS I демонстрируют следующее поведение:
* **Любая команда после опкодов типа «ветвление» или «переход» выполняется безусловным образом**: Поэтому после ветвления или перехода разработчики должны вручную заполнять конвейер бесполезными командами (например, `вычислить 0 плюс 0`), чтобы устранить конфликты. Эти заполнители называются **слотами задержек ветвления**.
+ Современные CPU превратили это явление в преимущество: [прогнозирование ветвления](https://www.copetti.org/writings/consoles/gamecube/#cpu). Благодаря добавлению дополнительных цепей для обнаружения конфликтов CPU отбрасывает новые вычисления, если условие ветвления/перехода не было соблюдено. Но если оно соблюдено, то CPU экономит немного времени.
* **Команды типа «загрузка» не вызывают простой конвейер, пока не будут доступны полученные данные**: второй этап конвейера (называемый RD, или Read and Decode) собирает операторы, которые будут использоваться для вычислений на третьем этапе (ALU, арифметическо-логическое устройство). Четвёртый этап (MEM, сокращение от «access MEMory», «доступ к памяти») ищет данные в памяти (т. е. в основной ОЗУ, CD-приводе и т. д.). Здесь возникает проблема: ко времени, когда команда `load` соберёт данные снаружи, следующая команда уже получила операции. Это значит, что команда, зависящая от значений предыдущей команды `load`, требует между ними заполнителя, чтобы правильные операторы были получены вовремя.
Как мы видим из примера, некоторые слоты задержки заполнены полезными командами, выполняющими вычисления, на которые не влияет конфликт. Поэтому слоты задержки не всегда подразумевают потраченные впустую такты процессора.
В большинстве случаев компилятор или ассемблер автоматически изменяет порядок команд для заполнения слотов или, в крайнем случае, добавляет бесполезные заполнители. То есть, в целом, это явление имеет и плюсы, и минусы.
---
Источники
---------
### Общая информация
* Martin Korth, [Nocash PSX Specifications](https://problemkaputt.de/psx-spx.htm).
* Википедия, [модели PlayStation](https://en.wikipedia.org/wiki/PlayStation_models).
### CPU
* MAMEdev,
[исходный код эмулятора CPU PlayStation](https://github.com/mamedev/mame/blob/master/src/devices/cpu/psx/psx.cpp).
* Jakub Czekański, [Логи времени доступа к CPU](https://github.com/JaCzekanski/ps1-tests/blob/master/cpu/access-time/psx.log).
* Integrated Device Technology, [R30xx Family Software Reference Manual](https://cgi.cse.unsw.edu.au/~cs3231/doc/R3000.pdf).
* LSI Logic, [LR33300 User's Manual](http://www.sm.luth.se/csee/courses/smd/D0013E/manual/manual.html).
* Raymond Chen, [The MIPS R4000, part 8: Control transfer](https://devblogs.microsoft.com/oldnewthing/20180411-00/?p=98485).
* Gabriel Ivancescu, [Fixed Point Arithmetic and Tricks](http://x86asm.net/articles/fixed-point-arithmetic-and-tricks/index.html).
* Michael Sabin, [The PlayStation 1 Video (STR Format)](https://github.com/m35/jpsxdec/blob/readme/jpsxdec/PlayStation1_STR_format.txt).
* Jakub Czekański, [encode.cpp (кодировщик MDEC на C++)](https://github.com/JaCzekanski/mdec-tools/blob/develop/src/encode.cpp#L19-L44). Github. | https://habr.com/ru/post/599869/ | null | ru | null |
# О применении RazorPages в консольных и десктопных приложениях
Иногда хочется автоматически создавать текстовые файлы, подставляя в шаблоны значения каких-то полей. Например, это могут быть исходники классов-хелперов на основе какого-то интерфейса, какие-то отчеты в XML, которые хотя и можно сгенерировать полностью программно, но на практике это может быть достаточно трудный для сопровождения код. Наверное, те, кто сталкивался с такой потребностью, смогут дополнить этот список. Приведу для примера задачу с хелперами.
Проблема
--------
Предположим, мы создаём клиент-серверное приложение. На сервере у нас крутится MVC ASP.NET, основное клиентское приложение - WPF, но не исключено использование в будущем и других клиентов.
Чтобы при разработке модели как на клиенте, так и на сервере не заниматься сериализацией и десериализацией, мы решили клиент-серверное взаимодействие устроить по принципу коннектора, когда на клиенте вызывается некоторый метод, что приводит к вызову такого же (почти) на сервере.
Сама концепция здесь не важна, главное, что мы столкнулись с необходимостью строить исходники хелперов по интерфейсу клиентской части коннектора. Данный интерфейс можно считать недорогим вариантом Contract First парадигмы.
Пусть интерфейс такой:
```
using Net.Leksi.RestContract;
using System.Collections.ObjectModel;
namespace DtoKit.Demo;
public interface IConnector
{
[RoutePath("/shipCalls/{filter}/{amount:double}/{date}")]
[HttpMethodGet]
[Authorization(Roles = "1, 2, 3")]
Task GetShipCalls(DateTime date, double amount, ShipCallsFilter filter,
ObservableCollection list);
[RoutePath("/form")]
[HttpMethodPost]
Task Commit([Body] IShipCall shipCall);
}
```
Здесь мы используем свои атрибуты, чтобы не включать в клиент зависимость от платформы ASP.NET, параметры, входящие в роутинг или являющиеся телом POST-запроса, должны быть в серверном методе, соответствующие атрибуты ASP.NET и пераметры из роутинга должны быть в контроллере. Остальные возможные параметры "остаются на клиенте". Всё должно однообразно сериализоваться/десериализоваться.
Мы хотим, чтобы при перестроении сборки, содержащей `IConnector`, автоматически консольным приложением создавались следующие исходники.
Родительский класс для клиентской части
```
//------------------------------
// Connector base
// DtoKit.Demo.DemoConnectorBase
// (Generated automatically)
//------------------------------
using Microsoft.Extensions.DependencyInjection;
using Net.Leksi.Dto;
using Net.Leksi.RestContract;
using System.Net.Http.Json;
using System.Text.Json;
using System.Web;
namespace DtoKit.Demo;
public class DemoConnectorBase
{
private readonly HttpConnector _httpConnector;
public DemoConnectorBase(HttpConnector httpConnector)
{
_httpConnector = httpConnector;
}
public Task GetShipCalls(DateTime date, Double amount,
ShipCallsFilter filter)
{
DtoJsonConverterFactory getConverter = \_httpConnector.Services
.GetRequiredService();
getConverter.KeysProcessing = KeysProcessing.OnlyKeys;
JsonSerializerOptions getOptions = new();
getOptions.Converters.Add(getConverter);
string \_date = HttpUtility.UrlEncode(
JsonSerializer.Serialize(date, getOptions));
string \_amount = HttpUtility.UrlEncode(
JsonSerializer.Serialize(amount, getOptions));
string \_filter = HttpUtility.UrlEncode(
JsonSerializer.Serialize(filter, getOptions));
string route = $"/shipCalls/{\_filter}/{\_amount}/{\_date}";
HttpRequestMessage httpRequest = new(HttpMethod.Get, route);
return \_httpConnector.SendAsync(httpRequest);
}
public Task Commit(IShipCall shipCall)
{
string route = $"/form";
HttpRequestMessage httpRequest = new(HttpMethod.Post, route);
DtoJsonConverterFactory postConverter = \_httpConnector.Services
.GetRequiredService();
JsonSerializerOptions postOptions = new();
postOptions.Converters.Add(postConverter);
httpRequest.Content = JsonContent.Create(shipCall, typeof(IShipCall),
default, postOptions);
return \_httpConnector.SendAsync(httpRequest);
}
}
```
которую мы будем использовать в самом
коннекторе:
```
using Net.Leksi.RestContract;
using System.Collections.ObjectModel;
namespace DtoKit.Demo;
public class Connector : DemoConnectorBase, IConnector
{
public Connector(HttpConnector httpConnector) : base(httpConnector) { }
public async Task GetShipCalls(DateTime date, double amount,
ShipCallsFilter filter, ObservableCollection list)
{
// Возможная логика до отправки запроса
HttpResponseMessage response = await base.GetShipCalls(date, amount,
filter);
Console.WriteLine(response.StatusCode);
// Возможная логика после получения ответа, включая запись результата в
// ObservableCollection list для тображения в UI
// (этот параметр на сервере неизвестен)
}
public async Task Commit(IShipCall shipCall)
{
HttpResponseMessage response = await base.Commit(shipCall);
Console.WriteLine(response.StatusCode);
}
}
```
На сервере мы собираемся в
качестве контроллера разместить:
```
//------------------------------
// MVC Controller proxy
// DtoKit.Demo.DemoControllerProxy
// (Generated automatically)
//------------------------------
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Net.Leksi.Dto;
using System.Text.Json;
namespace DtoKit.Demo;
public class DemoControllerProxy : Controller
{
[Route("/shipCalls/{filter}/{amount:double}/{date}")]
[HttpGet]
[Authorize(Roles = "1, 2, 3")]
public async Task GetShipCalls(String date, Double amount, String filter)
{
DtoJsonConverterFactory converter = HttpContext.RequestServices
.GetRequiredService();
JsonSerializerOptions options = new();
options.Converters.Add(converter);
DateTime \_date = JsonSerializer.Deserialize(date, options);
ShipCallsFilter \_filter = JsonSerializer.Deserialize(
filter, options);
Controller controller = (Controller)HttpContext.RequestServices
.GetRequiredService();
controller.ControllerContext = ControllerContext;
await ((IDemoController)controller).GetShipCalls(\_date, amount, \_filter);
}
[Route("/form")]
[HttpPost]
public async Task Commit()
{
DtoJsonConverterFactory converter = HttpContext.RequestServices
.GetRequiredService();
JsonSerializerOptions options = new();
options.Converters.Add(converter);
IShipCall shipCall = await HttpContext.Request
.ReadFromJsonAsync(options);
Controller controller = (Controller)HttpContext.RequestServices
.GetRequiredService();
controller.ControllerContext = ControllerContext;
await ((IDemoController)controller).Commit(shipCall);
}
}
```
и интерфейс реального контроллера, содержащего логику:
интерфейс реального контроллера, содержащего логику:
```
//------------------------------
// MVC Controller interface
// DtoKit.Demo.IDemoController
// (Generated automatically)
//------------------------------
namespace DtoKit.Demo;
public interface IDemoController
{
Task GetShipCalls(DateTime date, Double amount, ShipCallsFilter filter);
Task Commit(IShipCall shipCall);
}
```
Нам бы могла подойти платформа RazorPages
-----------------------------------------
Если бы можно было применить её в приложении командной строки, мы бы использовали для нашей цели следующие шаблоны.
Шаблон для родительского класса коннектора
```
@page
@using Net.Leksi.RestContract
@model Net.Leksi.RestContract.Pages.ConnectorBaseModel
//------------------------------
// Connector base
// @string.Join(".", new string[] { Model.NamespaceValue, Model.ClassName})
// (Generated automatically)
//------------------------------
@foreach(string usng in Model.Usings)
{
using @usng;
}
namespace @Model.NamespaceValue;
public class @Model.ClassName
{
private readonly HttpConnector _httpConnector;
public @Model.ClassName@{}(HttpConnector httpConnector)
{
_httpConnector = httpConnector;
}
@foreach (MethodModel mm in Model.Methods)
{
public Task @mm.Name@{}(@for(int i = 0; i < mm.Parameters.Count; ++i)
{
if(i > 0){, }
@mm.Parameters[i].Type @mm.Parameters[i].Name
})
{@if(mm.HasSerialized)
{
DtoJsonConverterFactory @mm.GetConverterVariable = \_httpConnector.Services.GetRequiredService();
@mm.GetConverterVariable@{}.KeysProcessing = KeysProcessing.OnlyKeys;
JsonSerializerOptions @mm.GetOptionsVariable = new();
@mm.GetOptionsVariable@{}.Converters.Add(@mm.GetConverterVariable);
foreach(Tuple tuple in mm.Deserializing)
{
@tuple.Item1 @tuple.Item2 = HttpUtility.UrlEncode(JsonSerializer.Serialize(@tuple.Item3, @mm.GetOptionsVariable));
}
} @\* @if(mm.HasSerialized) \*@
string @mm.RouteVariable = @Html.Raw($"$\"{@mm.RouteValue}\"");
HttpRequestMessage @mm.HttpRequestVariable = new(HttpMethod.@mm.HttpMethod, @mm.RouteVariable);
@if(mm.PostConverterVariable is { })
{
DtoJsonConverterFactory @mm.PostConverterVariable = \_httpConnector.Services.GetRequiredService();
JsonSerializerOptions @mm.PostOptionsVariable = new();
@mm.PostOptionsVariable@{}.Converters.Add(@mm.PostConverterVariable);
@mm.HttpRequestVariable@{}.Content = JsonContent.Create(@mm.BodyVariable, typeof(@mm.BodyType), default, @mm.PostOptionsVariable);
}
return \_httpConnector.SendAsync(@mm.HttpRequestVariable);
}@\* public async ... \*@
}@* @foreach (MethodModel mm in Model.Methods) *@
}
```
Шаблон для прокси-контроллера
```
@page
@using Net.Leksi.RestContract
@model Net.Leksi.RestContract.Pages.ControllerProxyModel
//------------------------------
// MVC Controller proxy
// @string.Join(".", new string[] { Model.NamespaceValue, Model.ClassName})
// (Generated automatically)
//------------------------------
@foreach(string usng in Model.Usings)
{
using @usng;
}
namespace @Model.NamespaceValue;
public class @Model.ClassName: Controller
{
@foreach (MethodModel mm in Model.Methods)
{
foreach(AttributeModel am in mm.Attributes)
{
[@am.Name@if (am.Properties.Count > 0) {(
string[] keys = am.Properties.Keys.ToArray();
for(int i = 0; i < keys.Length; ++i)
{
if(i > 0){, }
if(!string.IsNullOrEmpty(keys[i])){@keys[i] = }@Html.Raw(am.Properties[keys[i]])
}
) }]
}
public async @mm.Type @mm.Name@{}(@for(int i = 0; i < mm.Parameters.Count; ++i)
{
if(i > 0){, }
@mm.Parameters[i].Type @mm.Parameters[i].Name
})
{@if(mm.HasSerialized)
{
DtoJsonConverterFactory @mm.GetConverterVariable = HttpContext.RequestServices.GetRequiredService();
JsonSerializerOptions @mm.GetOptionsVariable = new();
@mm.GetOptionsVariable@{}.Converters.Add(@mm.GetConverterVariable);
foreach(Tuple tuple in mm.Deserializing)
{
if(tuple.Item3 is null)
{
@tuple.Item1 @tuple.Item2 = await HttpContext.Request.ReadFromJsonAsync<@tuple.Item1>(@mm.GetOptionsVariable);
}
else
{
@tuple.Item1 @tuple.Item2 = JsonSerializer.Deserialize<@tuple.Item1>(@tuple.Item3, @mm.GetOptionsVariable);
}
}
} @\* @if(mm.HasSerialized) \*@
Controller @mm.ControllerVariable = (Controller)HttpContext.RequestServices.GetRequiredService<@mm.ControllerInterfaceClassName>();
@mm.ControllerVariable@{}.ControllerContext = ControllerContext;
await ((@mm.ControllerInterfaceClassName)@mm.ControllerVariable).@mm.Name@{}(@for(int i = 0; i < mm.ControllerParameters.Count; ++i)
{
if(i > 0){, }
@mm.ControllerParameters[i]
});
}@\* public async ... \*@
}@* @foreach (MethodModel mm in Model.Methods) *@
}
```
Шаблон для интерфейса контроллера
```
@page
@using Net.Leksi.RestContract
@model Net.Leksi.RestContract.Pages.ControllerInterfaceModel
//------------------------------
// MVC Controller interface
// @string.Join(".", new string[] { Model.NamespaceValue, Model.ClassName})
// (Generated automatically)
//------------------------------
@foreach(string usng in Model.Usings)
{
using @usng;
}
namespace @Model.NamespaceValue;
public interface @Model.ClassName
{
@foreach (MethodModel mm in Model.Methods)
{
@mm.Type @mm.Name(
@for(int i = 0; i < mm.Parameters.Count; ++i)
{
if(i > 0)
{
,
}
@mm.Parameters[i].Type @mm.Parameters[i].Name
}
);
}
}
```
Инкапсуляция RazorPages в консольное приложение
-----------------------------------------------
Напишем простой класс, который будет делать это в принципе, без привязки к конкретной задаче.
```
public static class Generator
{
...
public static async IAsyncEnumerable>
Generate(IEnumerable requisite, IEnumerable requests)
{
...
}
```
Здесь `IEnumerable requisite` - всё, что понадобится внутри. Конкретно `object` может быть:
* Экземпляр класса, который содержит информацию или предоставляет доступ к информации, необходимой какой-либо страничной модели. Этот объект будет зарегистрирован в службах внедрения зависимости как `ServiceLifetime.Singleton` под своим типом.
* `KeyValuePair`, где `Value`- экземпляр, как описано в предыдущем пункте, который будет зарегистрирован как `ServiceLifetime.Singleton` под типом `Key`.
* `Type` - будет зарегистрирован как `ServiceLifetime.Transient` .
* `KeyValuePair` - `Value` будет зарегистрирован как `ServiceLifetime.Transient` под типом `Key`.
* `Assembly` - сборка, содержащая в папке Pages сами страницы с моделями. Если другие объекты из предыдущих пунктов содержатся в этой сборке, то её можно не добавлять.
`IEnumerable requests` - последовательность запросов к страницам, обычные пути. Можно при желании в зависимости от данных или предыдущих ответов решать, какой будет следующий запрос. Именно поэтому мы не используем здесь коллекцию или массив. То же самое с реквизитом, но он считывается до запросов, так что может зависеть только от исходных данных.
Возвращаемое значение `IAsyncEnumerable>` - пары, где `Key` - строка запроса, а `Value` - либо строка содержимое ответа, либо `Exception`, если что-то пошло не так при выполнении этого запроса. Сам метод не падает, вызывающий код решает, что с этим делать.
Код класса находится здесь
```
using Microsoft.AspNetCore.Diagnostics;
using System.Net.NetworkInformation;
using System.Reflection;
namespace Net.Leksi.DocsRazorator;
public static class Generator
{
private const string SecretWordHeader = "X-Secret-Word";
private const int MaxTcpPort = 65535;
private const int StartTcpPort = 5000;
public static async IAsyncEnumerable> Generate(IEnumerable requisite,
IEnumerable requests)
{
ManualResetEventSlim appStartedGate = new();
WebApplication app = null!;
HttpClient client = null!;
string secretWord = Guid.NewGuid().ToString();
Exception? razorPageException = null;
appStartedGate.Reset();
Task loadTask = Task.Run(() =>
{
int port = MaxTcpPort + 1;
List assemblies = new();
List services = new();
foreach (object obj in requisite)
{
if (obj is Assembly asm)
{
if (!assemblies.Contains(asm))
{
assemblies.Add(asm);
}
}
else if (obj is KeyValuePair typeTypePair)
{
Assembly assembly = typeTypePair.Value.Assembly;
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
if (services.Find(v => v is KeyValuePair p && p.Key == typeTypePair.Key
&& Object.ReferenceEquals(p.Value, typeTypePair.Value)) is null)
{
services.Add(obj);
}
}
else if (obj is KeyValuePair typeObjectPair)
{
Assembly assembly = typeObjectPair.Value.GetType().Assembly;
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
if (services.Find(v => v is KeyValuePair p && p.Key == typeObjectPair.Key
&& Object.ReferenceEquals(p.Value, typeObjectPair.Value)) is null)
{
services.Add(obj);
}
}
else if (obj is Type type)
{
Assembly assembly = type.Assembly;
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
if (!services.Contains(obj))
{
services.Add(obj);
}
}
else
{
Assembly assembly = obj.GetType().Assembly;
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
if (!services.Contains(obj))
{
services.Add(obj);
}
}
}
while (true)
{
IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
int[] usedPorts = ipGlobalProperties.GetActiveTcpConnections()
.Select(v => v.LocalEndPoint.Port).Where(v => v >= StartTcpPort).OrderBy(v => v).ToArray();
for (int i = 1; i < usedPorts.Length; ++i)
{
if (usedPorts[i] > usedPorts[i - 1] + 1)
{
port = usedPorts[i] - 1;
break;
}
}
if (port > MaxTcpPort)
{
try
{
throw new Exception("No TCP port is available.");
}
finally
{
appStartedGate.Set();
}
}
WebApplicationBuilder builder = WebApplication.CreateBuilder(new string[] { });
builder.Logging.ClearProviders();
builder.Services.AddRazorPages();
IMvcBuilder mvcBuilder = builder.Services.AddControllersWithViews();
foreach (Assembly assembly in assemblies)
{
mvcBuilder.AddApplicationPart(assembly);
}
foreach (object obj in services)
{
if(obj is KeyValuePair typeTypePair)
{
builder.Services.AddTransient(typeTypePair.Key, typeTypePair.Value);
}
else if (obj is KeyValuePair typeObjectPair)
{
builder.Services.AddSingleton(typeObjectPair.Key, op =>
{
return typeObjectPair.Value;
});
}
else if(obj is Type type)
{
builder.Services.AddTransient(type);
}
else
{
builder.Services.AddSingleton(obj.GetType(), op =>
{
return obj;
});
}
}
app = builder.Build();
app.UseExceptionHandler(eapp =>
{
eapp.Run(async context =>
{
var exceptionHandlerPathFeature =
context.Features.Get();
razorPageException = exceptionHandlerPathFeature?.Error;
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
});
});
app.Use(async (context, next) =>
{
if (!context.Request.Headers.ContainsKey(SecretWordHeader) || !context.Request.Headers[SecretWordHeader].Contains(secretWord))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
await context.Response.WriteAsync(String.Empty);
}
else
{
await next.Invoke(context);
}
});
app.MapRazorPages();
app.Lifetime.ApplicationStarted.Register(() =>
{
appStartedGate.Set();
});
app.Urls.Clear();
app.Urls.Add($"http://localhost:{port}");
try
{
app.Run();
break;
}
catch (IOException ex) { }
}
});
appStartedGate.Wait();
if (loadTask.IsFaulted)
{
throw loadTask.Exception;
}
client = new HttpClient();
client.BaseAddress = new Uri(app.Urls.First());
client.DefaultRequestHeaders.Add(SecretWordHeader, secretWord);
foreach (string request in requests)
{
razorPageException = null;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, request);
HttpResponseMessage response = await client.SendAsync(requestMessage);
if(razorPageException is { })
{
yield return new KeyValuePair(request, razorPageException);
}
else if (response.IsSuccessStatusCode)
{
yield return new KeyValuePair(request, await response.Content.ReadAsStringAsync());
}
}
await app.StopAsync();
}
}
```
Посмотрим, что происходит
```
{
ManualResetEventSlim appStartedGate = new();
WebApplication app = null!;
HttpClient client = null!;
string secretWord = Guid.NewGuid().ToString();
Exception? razorPageException = null;
appStartedGate.Reset();
...
}
```
Ворота `ManualResetEventSlim appStartedGate` откроются, когда загрузится локальный сервер `WebApplication app`. `HttpClient client` будет осуществлять запросы. `string secretWord` будем передавать в заголовках запросов, чтобы не пускать посторонних. В `Exception? razorPageException` будем искать `Exception`, если таковой возник при обработке запроса.
Запускаем `WebApplication app` ...
```
{
...
// Задача запускает WebApplication
Task loadTask = Task.Run(() =>
{
int port = MaxTcpPort + 1;
List assemblies = new();
List services = new();
foreach (object obj in requisite)
{
// Сортируем реквизиты
...
}
while (true)
{
// Ищем свободный TCP порт
IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
int[] usedPorts = ipGlobalProperties.GetActiveTcpConnections()
.Select(v => v.LocalEndPoint.Port).Where(v => v >= StartTcpPort).OrderBy(v => v).ToArray();
for (int i = 1; i < usedPorts.Length; ++i)
{
if (usedPorts[i] > usedPorts[i - 1] + 1)
{
port = usedPorts[i] - 1;
break;
}
}
if (port > MaxTcpPort)
{
try
{
throw new Exception("No TCP port is available.");
}
finally
{
appStartedGate.Set();
}
}
// Конфигурируем WebApplication
WebApplicationBuilder builder = WebApplication.CreateBuilder(new string[] { });
builder.Logging.ClearProviders();
builder.Services.AddRazorPages();
// Добавляем сборки со страницами
IMvcBuilder mvcBuilder = builder.Services.AddControllersWithViews();
foreach (Assembly assembly in assemblies)
{
mvcBuilder.AddApplicationPart(assembly);
}
foreach (object obj in services)
{
// Регистрируем объекты и типы
...
}
app = builder.Build();
// При исключении заносим его в razorPageException и возвращаем
// StatusCodes.Status500InternalServerError
app.UseExceptionHandler(eapp =>
{
eapp.Run(async context =>
{
var exceptionHandlerPathFeature =
context.Features.Get();
razorPageException = exceptionHandlerPathFeature?.Error;
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
});
});
// Отсекаем запросы не от нас
app.Use(async (context, next) =>
{
if (!context.Request.Headers.ContainsKey(SecretWordHeader) || !context.Request.Headers[SecretWordHeader].Contains(secretWord))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
await context.Response.WriteAsync(String.Empty);
}
else
{
await next.Invoke(context);
}
});
app.MapRazorPages();
// Открываем ворота appStartedGate, когда готовы обрабатывать запросы
app.Lifetime.ApplicationStarted.Register(() =>
{
appStartedGate.Set();
});
// Пытаемся запуститься на выбранном порту,
// но если ВДРУГ он уже занят, повторяем попытку с другим
app.Urls.Clear();
app.Urls.Add($"http://localhost:{port}");
try
{
app.Run();
break;
}
catch (IOException ex) { }
}
});
...
}
```
И начинаем слать запросы
```
{
...
// Ждём сигнал на старт
appStartedGate.Wait();
// Если приложение не смогло запуститься, валимся
if (loadTask.IsFaulted)
{
throw loadTask.Exception;
}
// Настраиваем клиента
client = new HttpClient();
client.BaseAddress = new Uri(app.Urls.First());
client.DefaultRequestHeaders.Add(SecretWordHeader, secretWord);
// Шлём запросы
foreach (string request in requests)
{
// убираем прошлое исключение
razorPageException = null;
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, request);
HttpResponseMessage response = await client.SendAsync(requestMessage);
if(razorPageException is { })
{
// Если получили исключение, возвращаем исключение
yield return new KeyValuePair(request, razorPageException);
}
else
{
// возвращаем результат
yield return new KeyValuePair(request, await response.Content.ReadAsStringAsync());
}
}
// Запросы кончились, занавес
await app.StopAsync();
}
```
Использование для нашей задачи
------------------------------
Создадим проект:
Удалим всё ненужное, добавим нужное:
Модели у нас одинаковые, только строятся по разному, поэтому их унаследуем от BasePageModel:
```
using Microsoft.AspNetCore.Mvc.RazorPages;
namespace Net.Leksi.RestContract;
public class BasePageModel: PageModel
{
internal string NamespaceValue { get; set; }
internal string ClassName { get; set; }
internal List Usings { get; set; }
internal List Methods { get; set; }
}
```
Сами модели заполняем извне с помощью билдера, полученного из внедрения зависимостей.
```
using Microsoft.AspNetCore.Mvc;
namespace Net.Leksi.RestContract.Pages;
public class ConnectorBaseModel : BasePageModel
{
public void OnGet([FromServices] IConnectorBaseBuilder builder)
{
builder.BuildConnectorBase(this);
}
}
```
```
using Microsoft.AspNetCore.Mvc;
namespace Net.Leksi.RestContract.Pages;
public class ControllerInterfaceModel : BasePageModel
{
public void OnGet([FromServices] IControllerInterfaceBuilder builder)
{
builder.BuildControllerInterface(this);
}
}
```
```
using Microsoft.AspNetCore.Mvc;
namespace Net.Leksi.RestContract.Pages
{
public class ControllerProxyModel : BasePageModel
{
public void OnGet([FromServices] IControllerProxyBuilder builder)
{
builder.BuildControllerProxy(this);
}
}
}
```
Точкой входа является метод класса HelpersBuilder, который реализует все три интерфейса, которые ждут модели и сам является реквизитом:
```
public class HelpersBuilder : IControllerInterfaceBuilder, IControllerProxyBuilder, IConnectorBaseBuilder
{
...
public async Task BuildHelpers(string controllerInterfaceFullName, string controllerProxyFullName,
string connectorBaseFullName)
{
CollectRequisites(controllerInterfaceFullName, controllerProxyFullName, connectorBaseFullName);
await foreach (KeyValuePair result in Generator.Generate(
new object[] {
new KeyValuePair(typeof(IConnectorBaseBuilder), this),
new KeyValuePair(typeof(IControllerInterfaceBuilder), this),
new KeyValuePair(typeof(IControllerProxyBuilder), this)
},
new string[] {
"ConnectorBase",
"ControllerInterface",
"ControllerProxy",
}
))
{
if (result.Value is Exception)
{
Console.WriteLine($"// {result.Key}");
}
Console.WriteLine(result.Value);
}
}
...
public void BuildConnectorBase(ConnectorBaseModel model)
{
...
}
...
public void BuildControllerProxy(ControllerProxyModel model)
{
...
}
...
public void BuildControllerInterface(ControllerInterfaceModel model)
{
...
}
...
private void CollectRequisites(string controllerFullName,
string proxyFullName, string connectorBaseFullName)
{
...
}
...
}
```
Запустим в виде юнит-теста опять же для простоты
```
public class RestContract
{
private static IHost _host;
static RestContract()
{
_host = Host.CreateDefaultBuilder()
.ConfigureServices(serviceCollection =>
{
...
serviceCollection.AddTransient();
}).Build();
Trace.Listeners.Add(new ConsoleTraceListener());
Trace.AutoFlush = true;
}
[Test]
public async Task BuildRestHelpers()
{
HelpersBuilder codeGenerator = \_host.Services.GetRequiredService();
await codeGenerator.BuildHelpers(
"DtoKit.Demo.IDemoController", "DtoKit.Demo.DemoControllerProxy",
"DtoKit.Demo.DemoConnectorBase");
}
}
```
Разложим типы по файлам и разместим в сервере и клиенте
Все исходники:
<https://github.com/Leksiqq/DocsRazorator/tree/v1.0.0/Library>
<https://github.com/Leksiqq/RestContract/tree/v1.0.0/HelpersBuilder>
<https://github.com/Leksiqq/DtoRestDemo> | https://habr.com/ru/post/664712/ | null | ru | null |
# Применение оконных функций и CTE в MySQL 8.0 для реализации накопительного итога без хаков
***Прим. перев.**: в этой статье тимлид британской компании Ticketsolve делится решением своей весьма специфичной проблемы, демонстрируя при этом общие подходы к созданию так называемых accumulating (накопительных) функций с помощью современных возможностей MySQL 8.0. Его листинги наглядны и снабжены подробными объяснениями, что помогает вникнуть в суть проблематики даже тем, кто не погружался в неё столь глубоко.*
Обычная стратегия для выполнения обновлений с использованием накопительных функций в MySQL — применение пользовательских переменных и паттерна `UPDATE [...] SET mycol = (@myvar := EXPRESSION(@myvar, mycol))`.
Этот паттерн плохо работает с оптимизатором (приводя к недетерминированному поведению), поэтому от него решили отказаться. В результате возникла некая пустота, поскольку (относительно) комплексную логику теперь сложнее реализовать (по крайней мере, с той же простотой).
В статье пойдет речь о двух способах ее реализации: с использованием оконных функций (канонический подход) и с помощью рекурсивных СТЕ (общих табличных выражений).
Требования и предыстория
------------------------
Хотя СТЕ достаточно интуитивно понятны, тем, кто не очень хорошо знаком с ними, я рекомендую обратиться к моей [предыдущей публикации на эту тему](https://saveriomiroddi.github.io/Generating-sequences-ranges-via-mysql-8.0-ctes/).
То же самое справедливо и для оконных функций: я буду подробно комментировать запросы/концепции, но общее представление все же не помешает. Оконным функциям посвящено огромное количество книг и публикаций (именно поэтому я до сих пор не писал о них); при этом в большинстве примеров вычисления проводятся либо на финансовых результатах, либо на демографических показателях. Однако в данной статье я буду использовать реальный случай.
Что касается ПО, рекомендую воспользоваться MySQL 8.0.19 (но это не обязательно). Все выражения должны выполняться в одной и той же консоли, чтобы повторно использовать `@venue_id`.
В мире ПО существует известная архитектурная дилемма: реализовывать логику на уровне приложения или на уровне базы данных? Хотя это вполне уместный вопрос, в нашем случае я исхожу из предположения, что логика *должна* остаться на уровне базы; причиной для этого могут быть, например, требования к скорости (как и было в нашем случае).
Задача
------
В этой задаче мы распределяем места в некоем зале (театральном).
Для целей бизнеса требуется каждому месту присваивать так называемую «группировку» (grouping) — дополнительный номер, представляющий его.
Вот алгоритм определения значения группировки:
1. начинаем с 0 и верхнего левого места;
2. если есть пустующее место между текущим и предшествующим или это новый ряд, то прибавляем 2 к прошлому значению (если это не абсолютно первое место), в противном случае — увеличиваем значение на 1;
3. присваиваем группировку месту;
4. переходим к новому месту в том же ряду или к следующему ряду (если предыдущий закончился) и повторяем с пункта 2; продолжаем всё до тех пор, пока места не закончатся.
Алгоритм на псевдокоде:
```
current_grouping = 0
for each row:
for each number:
if (is_there_a_space_after_last_seat or is_a_new_row) and is_not_the_first_seat:
current_grouping += 2
else
current_grouping += 1
seat.grouping = current_grouping
```
В реальной жизни нам нужно, чтобы конфигурация слева давала значения, приведенные справа:
```
x→ 0 1 2 0 1 2
y ╭───┬───┬───╮ ╭───┬───┬───╮
↓ 0 │ x │ x │ │ │ 1 │ 2 │ │
├───┼───┼───┤ ├───┼───┼───┤
1 │ x │ │ x │ │ 4 │ │ 6 │
├───┼───┼───┤ ├───┼───┼───┤
2 │ x │ │ │ │ 8 │ │ │
╰───┴───┴───╯ ╰───┴───┴───╯
```
Подготовка
----------
Пусть базовая таблица имеет следующее минималистское строение:
```
CREATE TABLE seats (
id INT AUTO_INCREMENT PRIMARY KEY,
venue_id INT,
y INT,
x INT,
`row` VARCHAR(16),
number INT,
`grouping` INT,
UNIQUE venue_id_y_x (venue_id, y, x)
);
```
Нам, в общем-то, не нужны столбцы `row` и `number`. С другой стороны, мы не хотим использовать и таблицу, записи которой полностью содержатся в индексе (просто чтобы быть ближе к реальным задачам).
Основываясь на диаграмме выше, координаты каждого места имеют вид (y, x):
* (0, 0), (0, 1)
* (1, 0), (1, 2)
* (2, 0)
Обратите внимание, что мы используем *у* как первую координату, поскольку так проще следить за рядами.
Следует загрузить достаточно большое количество записей, чтобы помешать оптимизатору «найти» неожиданные короткие пути. Конечно, мы используем рекурсивные СТЕ:
```
INSERT INTO seats(venue_id, y, x, `row`, number)
WITH RECURSIVE venue_ids (id) AS
(
SELECT 0
UNION ALL
SELECT id + 1 FROM venue_ids WHERE id + 1 < 100000
)
SELECT /*+ SET_VAR(cte_max_recursion_depth = 1M) */
v.id,
c.y, c.x,
CHAR(ORD('A') + FLOOR(RAND() * 3) USING ASCII) `row`,
FLOOR(RAND() * 3) `number`
FROM venue_ids v
JOIN (
VALUES
ROW(0, 0),
ROW(0, 1),
ROW(1, 0),
ROW(1, 2),
ROW(2, 0)
) c (y, x)
;
ANALYZE TABLE seats;
```
Несколько замечаний:
1. Здесь СТЕ используется интересным (надеюсь!) образом: каждый цикл представляет venue\_id, но поскольку мы хотим, чтобы для каждого venue (цикла) генерировалось множество мест, мы делаем cross join (перекрестное соединение) с таблицей, содержащей данные о местах.
2. Используется конструктор рядов из версии v8.0.19 (`VALUES ROW()...`) чтобы представлять (соединяемую) таблицу, не создавая ее фактически.
3. Генерируются случайные значения для row и number в качестве заполнителей.
4. Для простоты повествования мы не занимались оптимизациями (например, типы данных шире, чем нужно; индексы добавляются до вставки записей и т.д.).
Старый подход
-------------
Старый добрый подход весьма прямолинеен и незамысловат:
```
SET @venue_id = 5000; -- произвольный venue id; любой (хранимый) id подойдет
SET @grouping = -1;
SET @y = -1;
SET @x = -1;
WITH seat_groupings (id, y, x, `grouping`, tmp_y, tmp_x) AS
(
SELECT
id, y, x,
@grouping := @grouping + 1 + (seats.x > @x + 1 OR seats.y != @y),
@y := seats.y,
@x := seats.x
FROM seats
WHERE venue_id = @venue_id
ORDER BY y, x
)
UPDATE
seats s
JOIN seat_groupings sg USING (id)
SET s.grouping = sg.grouping
;
-- Query OK, 5 rows affected, 3 warnings (0,00 sec)
```
Что ж, это было легко (но не забывайте о предупреждениях)!
Небольшое отступление: в данном случае я пользуюсь свойствами булевой арифметики. Следующие выражения эквивалентны:
```
SELECT seats.x > @x + 1 OR seats.y != @y `increment`;
SELECT IF (
seats.x > @x + 1 OR seats.y != @y,
1,
0
) `increment`;
```
Некоторые находят это интуитивно понятным, другие — нет; тут дело вкуса. Дальше я буду использовать более компактное выражение.
Давайте посмотрим на результат:
```
SELECT id, y, x, `grouping` FROM seats WHERE venue_id = @venue_id ORDER BY y, x;
-- +-------+------+------+----------+
-- | id | y | x | grouping |
-- +-------+------+------+----------+
-- | 24887 | 0 | 0 | 1 |
-- | 27186 | 0 | 1 | 2 |
-- | 29485 | 1 | 0 | 4 |
-- | 31784 | 1 | 2 | 6 |
-- | 34083 | 2 | 0 | 8 |
-- +-------+------+------+----------+
```
Отличный подход!
Увы, у него есть «незначительный» недостаток: он прекрасно работает за исключением тех случаев, когда не работает…
Все дело в том, что оптимизатор запросов вовсе не обязательно проводит вычисления слева направо, поэтому операции присваивания (:=) могут выполняться в неверном порядке, приводя к неправильному результату. С подобной проблемой люди часто сталкиваются после обновления MySQL.
В MySQL 8.0 этот функционал действительно признан устаревшим:
```
-- Запустить сразу после UPDATE.
--
SHOW WARNINGS\G
-- *************************** 1. row ***************************
-- Level: Warning
-- Code: 1287
-- Message: Setting user variables within expressions is deprecated and will be removed in a future release. Consider alternatives: 'SET variable=expression, ...', or 'SELECT expression(s) INTO variables(s)'.
-- [...]
```
Что ж, давайте исправим ситуацию!
Современный подход №1: оконные функции
--------------------------------------
Появление оконных функций было весьма долгожданным событием в мире MySQL.
Вообще говоря, «скользящая» природа оконных функций отлично сочетается с накопительными функциями. Однако некоторые сложные накопительные функции требуют наличия результатов последнего выражения — функциональность, которую оконные функции не поддерживают, поскольку работают на столбцах.
Это не означает, что проблему нельзя решить: просто ее необходимо переосмыслить.
В нашем случае можно разделить задачу на две части. Группировку для каждого места можно считать как сумму двух значений:
* порядкового номера каждого места,
* совокупного значения приращений всех мест, предшествующих данному.
Те, кто хорошо знаком с оконными функциями, распознают здесь типичные паттерны.
Порядковый номер каждого места — это встроенная функция:
```
ROW_NUMBER() OVER
```
А вот с совокупным значением все гораздо интереснее… Чтобы его вычислить, мы выполняем два действия:
* считаем приращение для каждого места и записываем его в таблицу (или СТЕ),
* затем, для каждого места, с помощью оконной функции суммируем приращения для этого места.
Давайте посмотрим на SQL:
```
WITH
increments (id, increment) AS
(
SELECT
id,
x > LAG(x, 1, x - 1) OVER tzw + 1 OR y != LAG(y, 1, y) OVER tzw
FROM seats
WHERE venue_id = @venue_id
WINDOW tzw AS (ORDER BY y, x)
)
SELECT
s.id, y, x,
ROW_NUMBER() OVER tzw + SUM(increment) OVER tzw `grouping`
FROM seats s
JOIN increments i USING (id)
WINDOW tzw AS (ORDER BY y, x)
;
-- +-------+---+---+----------+
-- | id | y | x | grouping |
-- +-------+---+---+----------+
-- | 24887 | 0 | 0 | 1 |
-- | 27186 | 0 | 1 | 2 |
-- | 29485 | 1 | 0 | 4 |
-- | 31784 | 1 | 2 | 6 |
-- | 34083 | 2 | 1 | 8 |
-- +-------+---+---+----------+
```
Здорово!
*(Обратите внимание, что с настоящего момента я опускаю UPDATE ради простоты).*
Давайте проанализируем запрос.
### Высокоуровневая логика
Следующее CTE *(отредактировано)*:
```
SELECT
id,
x > LAG(x, 1, x - 1) OVER tzw + 1 OR y != LAG(y, 1, y) OVER tzw `increment`
FROM seats
WHERE venue_id = @venue_id
WINDOW tzw AS (ORDER BY y, x)
;
-- +-------+-----------+
-- | id | increment |
-- +-------+-----------+
-- | 24887 | 0 |
-- | 27186 | 0 |
-- | 29485 | 1 |
-- | 31784 | 1 |
-- | 34083 | 1 |
-- +-------+-----------+
```
… вычисляет приращения для каждого места по сравнению с предыдущим (подробнее о `LAG()` — позже). Он работает на каждой записи и той, которая ей предшествует, и не является кумулятивным.
Теперь, чтобы подсчитать кумулятивные приращения, мы просто воспользуемся оконной функцией для вычисления суммы до каждого места и включая его:
```
-- (CTE here...)
SELECT
s.id, y, x,
ROW_NUMBER() OVER tzw `pos.`,
SUM(increment) OVER tzw `cum.incr.`
FROM seats s
JOIN increments i USING (id)
WINDOW tzw AS (ORDER BY y, x);
-- +-------+---+---+------+-----------+
-- | id | y | x | pos. | cum.incr. | (grouping)
-- +-------+---+---+------+-----------+
-- | 24887 | 0 | 0 | 1 | 0 | = 1 + 0 (curr.)
-- | 27186 | 0 | 1 | 2 | 0 | = 2 + 0 (#24887) + 0 (curr.)
-- | 29485 | 1 | 0 | 3 | 1 | = 3 + 0 (#24887) + 0 (#27186) + 1 (curr.)
-- | 31784 | 1 | 2 | 4 | 2 | = 4 + 0 (#24887) + 0 (#27186) + 1 (#29485) + 1 (curr.)
-- | 34083 | 2 | 1 | 5 | 3 | = 5 + 0 (#24887) + 0 (#27186) + 1 (#29485) + 1 (#31784)↵
-- +-------+---+---+------+-----------+ + 1 (curr.)
```
### Оконная функция LAG()
Функция LAG в своей простейшей форме (`LAG(x)`) возвращает предыдущее значение заданного столбца. Классическое неудобство с такими функциями — обработка первой(-ых) записи(-ей) в окне. Поскольку предыдущей записи нет, они возвращают NULL. В случае LAG можно указать нужное значение как третий параметр:
```
LAG(x, 1, x - 1) -- по умолчанию равно `x -1`
LAG(y, 1, y) -- по умолчанию равно `y`
```
Указывая значения по умолчанию, мы гарантируем, что к самому первому месту в границах окна будет применяться та же логика, что и для места, следующего за другим (х-1) и без смены ряда (у).
Альтернативным решением является использование `IFNULL`, однако выражения при этом получаются весьма громоздкими:
```
-- Оба корректны, но ужасны!
--
IFNULL(x > LAG(x) OVER tzw + 1 OR y != LAG(y) OVER tzw, 0)
IFNULL(x > LAG(x) OVER tzw + 1, FALSE) OR IFNULL(y != LAG(y) OVER tzw, FALSE)
```
Второй параметр в `LAG()` — это число позиций, на которые надо сдвигаться назад в рамках окна; 1 — это предыдущее значение (оно также установлено по умолчанию).
### Технические аспекты
#### Именованные окна
В нашем запросе много раз используется одно и то же окно. Следующие два запроса формально эквивалентны:
```
SELECT
id,
x > LAG(x, 1, x - 1) OVER tzw + 1
OR y != LAG(y, 1, y) OVER tzw
FROM seats
WHERE venue_id = @venue_id
WINDOW tzw AS (ORDER BY y, x);
SELECT
id,
x > LAG(x, 1, x - 1) OVER (ORDER BY y, x) + 1
OR y != LAG(y, 1, y) OVER (ORDER BY y, x)
FROM seats
WHERE venue_id = @venue_id;
```
Однако второй может повлечь неоптимальное поведение (с чем я сталкивался — по крайней мере, в прошлом): оптимизатор может посчитать окна независимыми и отдельно высчитывать каждое. По этой причине я советую всегда использовать именованные окна (по крайней мере, когда они повторяются).
#### Оператор PARTITION BY
Обычно оконные функции выполняются на партиции. В нашем случае это будет выглядеть следующим образом:
```
SELECT
id,
x > LAG(x, 1, x - 1) OVER tzw + 1
OR y != LAG(y, 1, y) OVER tzw
FROM seats
WHERE venue_id = @venue_id
WINDOW tzw AS (PARTITION BY venue_id ORDER BY y, x); -- здесь!
```
Поскольку окно соответствует полному набору записей (который фильтруется условием `WHERE`), нам не нужно указывать ее (партицию).
А вот если бы этот запрос нужно было запустить на всей таблице `seats`, тогда пришлось бы сделать так, чтобы окно сбрасывалось для каждого `venue_id`.
#### Сортировка
В запросе `ORDER BY` задается на уровне окна:
```
SELECT
id,
x > LAG(x, 1, x - 1) OVER tzw + 1
OR y != LAG(y, 1, y) OVER tzw
FROM seats
WHERE venue_id = @venue_id
WINDOW tzw AS (ORDER BY y, x)
```
При этом оконная сортировка идет отдельно от SELECT. Это очень важно! Поведение этого запроса:
```
SELECT
id,
x > LAG(x, 1, x - 1) OVER tzw + 1
OR y != LAG(y, 1, y) OVER tzw
FROM seats
WHERE venue_id = @venue_id
WINDOW tzw AS ()
ORDER BY y, x
```
… не определено. Давайте обратимся к [руководству](https://dev.mysql.com/doc/refman/8.0/en/window-functions-usage.html):
> Строки результата запроса определяются из выражения FROM после выполнения операторов WHERE, GROUP BY и HAVING, а выполнение в рамках окна происходит до ORDER BY, LIMIT и SELECT DISTINCT.
### Некоторые соображения
Если говорить в общих чертах, для решения задач подобного типа имеет смысл рассчитывать изменение состояния для каждой записи, а затем их суммировать — вместо того, чтобы представлять каждую запись как функцию предыдущей.
Это решение более сложное, чем функционал, который оно заменяет, но в то же время надежное. Увы, этот подход не всегда возможен или легко реализуем. Именно здесь в игру вступают рекурсивные СТЕ.
Современный подход №2: рекурсивные CTE
--------------------------------------
Этот подход требует небольших хитростей из-за ограниченных возможностей СТЕ в MySQL. С другой стороны, это универсальное, прямое решение, поэтому оно не требует какого-либо переосмысления глобального подхода.
Давайте начнем с упрощенной версии конечного запроса:
```
-- `p_` означает `Previous` и упрощает понимание условий
--
WITH RECURSIVE groupings (p_id, p_venue_id, p_y, p_x, p_grouping) AS
(
(
SELECT id, venue_id, y, x, 1
FROM seats
WHERE venue_id = @venue_id
ORDER BY y, x
LIMIT 1
)
UNION ALL
SELECT
s.id, s.venue_id, s.y, s.x,
p_grouping + 1 + (s.x > p_x + 1 OR s.y != p_y)
FROM groupings, seats s
WHERE s.venue_id = p_venue_id AND (s.y, s.x) > (p_y, p_x)
ORDER BY s.venue_id, s.y, s.x
LIMIT 1
)
SELECT * FROM groupings;
```
Бинго! Этот запрос (относительно) прост, но, что более важно, он выражает накопительную функцию группировки самым простым возможным образом:
```
p_grouping + 1 + (s.x > p_x + 1 OR s.y != p_y)
-- что эквивалентно следующему:
@grouping := @grouping + 1 + (seats.x > @x + 1 OR seats.y != @y),
@y := seats.y,
@x := seats.x
```
Логика понятна даже для тех, кто не слишком знаком с СТЕ. Первый ряд — это первое место в зале, по порядку:
```
SELECT id, venue_id, y, x, 1
FROM seats
WHERE venue_id = @venue_id
ORDER BY y, x
LIMIT 1
```
В рекурсивной части мы проводим итерацию:
```
SELECT
s.id, s.venue_id, s.y, s.x,
p_grouping + 1 + (s.x > p_x + 1 OR s.y != p_y)
FROM groupings, seats s
WHERE s.venue_id = p_venue_id AND (s.y, s.x) > (p_y, p_x)
ORDER BY s.venue_id, s.y, s.x
LIMIT 1
```
Условие `WHERE` вместе с операторами `ORDER BY` и `LIMIT` просто находит следующее место, то есть место с тем же `venue_id`, но с б*о*льшими координатами (x, y) в последовательности (venue\_id, x, y).
Часть `s.venue_id` в выражении сортировки очень важна! Она позволяет нам использовать индекс.
Оператор `SELECT`:
* выполняет накопление (вычисляет `(p_)grouping`),
* передает значения для текущего места (`s.id`, `s.venue_id`, `s.y`, `s.x`) в следующий цикл.
Мы выбираем `FROM groupings`, чтобы выполнить требования для рекурсивности СТЕ.
Здесь интересно то, что мы используем рекурсивное СТЕ как итератор, формируя выборку из таблицы `groupings` в рекурсивном подзапросе и соединяя ее с `seats`, чтобы найти данные для последующей обработки.
`JOIN` формально является перекрестным, однако из-за оператора `LIMIT` возвращается только одна запись.
### Рабочая версия
К сожалению, приведенный выше запрос не работает, поскольку `ORDER BY` в настоящее время не поддерживается в рекурсивных подзапросах. Кроме того, семантика `LIMIT` в том виде, в котором он используется здесь, отличается от типичной, которая [применяется к внешнему запросу](https://dev.mysql.com/doc/refman/8.0/en/with.html#common-table-expressions-recursive-examples):
> LIMIT теперь поддерживается [..] Воздействие на итоговый набор данных такое же, как при использовании LIMIT с внешним SELECT
Впрочем, это не такая уж серьезная проблема. Давайте взглянем на работающую версию:
```
WITH RECURSIVE groupings (p_id, p_venue_id, p_y, p_x, p_grouping) AS
(
(
SELECT id, venue_id, y, x, 1
FROM seats
WHERE venue_id = @venue_id
ORDER BY y, x
LIMIT 1
)
UNION ALL
SELECT
s.id, s.venue_id, s.y, s.x,
p_grouping + 1 + (s.x > p_x + 1 OR s.y != p_y)
FROM groupings, seats s WHERE s.id = (
SELECT si.id
FROM seats si
WHERE si.venue_id = p_venue_id AND (si.y, si.x) > (p_y, p_x)
ORDER BY si.venue_id, si.y, si.x
LIMIT 1
)
)
SELECT * FROM groupings;
-- +-------+------+------+------------+
-- | p_id | p_y | p_x | p_grouping |
-- +-------+------+------+------------+
-- | 24887 | 0 | 0 | 1 |
-- | 27186 | 0 | 1 | 2 |
-- | 29485 | 1 | 0 | 4 |
-- | 31784 | 1 | 2 | 6 |
-- | 34083 | 2 | 0 | 8 |
-- +-------+------+------+------------+
```
Немного некомфортно использовать подзапрос, но данный подход работает и boilerplate здесь минимален, так как в любом случае требуется несколько выражений.
Здесь вместо того, чтобы проводить упорядочивание и лимитирование, связанное с объединением `groupings` и `seats`, мы делаем это в рамках подзапроса и передаем во внешний запрос, который затем выбирает только целевую запись.
### Размышления о производительности
Давайте изучим план выполнения запроса с помощью EXPLAIN ANALYZE:
```
mysql> EXPLAIN ANALYZE WITH RECURSIVE groupings [...]
-> Table scan on groupings (actual time=0.000..0.001 rows=5 loops=1)
-> Materialize recursive CTE groupings (actual time=0.140..0.141 rows=5 loops=1)
-> Limit: 1 row(s) (actual time=0.019..0.019 rows=1 loops=1)
-> Index lookup on seats using venue_id_y_x (venue_id=(@venue_id)) (cost=0.75 rows=5) (actual time=0.018..0.018 rows=1 loops=1)
-> Repeat until convergence
-> Nested loop inner join (cost=3.43 rows=2) (actual time=0.017..0.053 rows=2 loops=2)
-> Scan new records on groupings (cost=2.73 rows=2) (actual time=0.001..0.001 rows=2 loops=2)
-> Filter: (s.id = (select #5)) (cost=0.30 rows=1) (actual time=0.020..0.020 rows=1 loops=5)
-> Single-row index lookup on s using PRIMARY (id=(select #5)) (cost=0.30 rows=1) (actual time=0.014..0.014 rows=1 loops=5)
-> Select #5 (subquery in condition; dependent)
-> Limit: 1 row(s) (actual time=0.007..0.008 rows=1 loops=9)
-> Filter: ((si.y,si.x) > (groupings.p_y,groupings.p_x)) (cost=0.75 rows=5) (actual time=0.007..0.007 rows=1 loops=9)
-> Index lookup on si using venue_id_y_x (venue_id=groupings.p_venue_id) (cost=0.75 rows=5) (actual time=0.006..0.006 rows=4 loops=9)
```
План вполне соответствует ожиданиям. В данном случае основа оптимального плана кроется в индексных поисках:
```
-> Nested loop inner join (cost=3.43 rows=2) (actual time=0.017..0.053 rows=2 loops=2)
-> Single-row index lookup on s using PRIMARY (id=(select #5)) (cost=0.30 rows=1) (actual time=0.014..0.014 rows=1 loops=5)
-> Index lookup on si using venue_id_y_x (venue_id=groupings.p_venue_id) (cost=0.75 rows=5) (actual time=0.006..0.006 rows=4 loops=9)
```
… имеющих первостепенное значение. Скорость работы значительно упадет, если производить сканирование индексов (то есть линейно сканировать записи индекса вместо того, чтобы искать сразу нужные).
Таким образом, чтобы эта стратегия работала, необходимо, чтобы связанные индексы были на месте *и* максимально эффективно использовались оптимизатором.
Если в будущем ограничения будут сняты, то отпадет и необходимость использовать подзапрос, что значительно упростит задачу для оптимизатора.
### Альтернатива для неоптимальных планов
В случае, если оптимальный план невозможно определить, используйте временную таблицу:
```
CREATE TEMPORARY TABLE selected_seats (
id INT NOT NULL PRIMARY KEY,
y INT,
x INT,
UNIQUE (y, x)
)
SELECT id, y, x
FROM seats WHERE venue_id = @venue_id;
WITH RECURSIVE
groupings (p_id, p_y, p_x, p_grouping) AS
(
(
SELECT id, y, x, 1
FROM seats
WHERE venue_id = @venue_id
ORDER BY y, x
LIMIT 1
)
UNION ALL
SELECT
s.id, s.y, s.x,
p_grouping + 1 + (s.x > p_x + 1 OR s.y != p_y)
FROM groupings, seats s WHERE s.id = (
SELECT ss.id
FROM selected_seats ss
WHERE (ss.y, ss.x) > (p_y, p_x)
ORDER BY ss.y, ss.x
LIMIT 1
)
)
SELECT * FROM groupings;
```
Даже если в этом запросе проходят индексные сканы, они обходятся «малой кровью», поскольку таблица `selected_seats` очень мала.
Заключение
----------
Я очень доволен тем, что эффективный, но в то же время имеющий определенные недостатки рабочий процесс теперь можно заменить достаточно простым функционалом, появившимися в MySQL 8.0.
Тем временем, развитие новых фич для 8.0 продолжается, что делает и без того удачный релиз ещё лучше.
Успешной рекурсии!
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Обновление MySQL (Percona Server) с 5.7 до 8.0](https://habr.com/ru/company/flant/blog/500706/)»;
* «[Базы данных и Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/431500/)»;
* «[Больше разработчиков должны знать это о базах данных](https://habr.com/ru/company/flant/blog/500850/)». | https://habr.com/ru/post/510686/ | null | ru | null |
# Нейросети и трейдинг. Часть 2: набор «сделай сам»
*Продолжение статьи [здесь](https://habr.com/ru/post/562092/).
Добавить нейросеть в MetaTrader5 можно [тут](https://www.mql5.com/ru/blogs/post/746398).*
В [прошлой статье](https://habr.com/ru/post/494964/) я описал как получилось добиться от нейросети предсказания тренда на реальном рынке. Статья вызвала интерес, но оказалось, что на вопрос «Где доказательства?» ответа нет. Действительно, тема нейросетей в трейдинге обсуждается много, есть публикации, ей посвещены ветки на профессиональных форумах. Но сколько ни погружайся в тему, сколько ни общайся со специалистами, остается впечатление, что все это какая-то ускользающая иллюзия. Нет ничего реально работающего, ничего такого, что хотя бы отдаленно, но реально могло связать нейросеть и прогноз движения цены. Отсюда и обоснованное мнение сообщества, что движение цены не поддается прогнозированию в принципе, а все эти разговоры ни о чем.
Предлагаю развеить эти сомнения раз и на всегда и перевести дискурс из области «может предсказывать или не может» в область «хорошо предсказывает или плохо». И сделаем мы это простым, быстрым и наглядным способом. Я дам готовый инструмент и каждый сможет получить результат на своем компьютере. Поможет нам в этом бесплатный проект GoogleColaboratory. Это открытая платформа для совметной разработки, все вычисления происходят на серверах Google, всё взаимодействие через браузер, регистрация не нужна.
Код для нашей работы открыт и уже заряжен в GoogleColab. Результаты обучения нейросети для каждого будет индивидуальные. Это связано с тем, что начальные веса раздаются случайным образом и результаты немного отличаются. Так же учтите, что история котировок представляет из себя очень зашумленные данные, поэтому качество обучения низкое, но достаточное для того, что бы увидеть как будет прогнозировать нейросеть. Прогноз должен получиться примерно на уровне хорошего индикатора.
Единственное где мы сократим наш путь — это сбор данных на истории торговой пары. Сбор производится приложением к MetaTrader5, процесс не сложный, но требует навыков работы с тестером в MetaTrader5. Подробная инструкция потянет на отдельную статью, поэтому используем заранее подготовленные данные для пары Евро/Доллар (тем, кто пользуется MT5 ссылка на Expert в конце статьи). Убедиться в том, что заранее подготовленные данные «не подглядывают вперед» и не подсказывают нейросети, можно будет на последнем этапе когда перейдем к тестированию реальным рынком.
Начнем…
### GoogleColaboratory
Наш «ноутбук» в GoogleColab можно найти по [этой ссылке](https://colab.research.google.com/drive/19CYXC7FbfJQfeBwDIgkTV2j-Gmi4njh2?usp=sharing). Не забудьте сначала залогинится в свою учетную запись на Google (или Gmail).
Копируйте «ноутбук» себе.
Теперь нужно последовательно запускать все блоки сверху вниз.
### 1. Установка библиотек
На этом этапе установится TensorFlow и другие библиотеки. Процесс закончится сам, ничего делать не требуется.
### 2. Загрузка и подготовка данных для обучения
На этом этапе будет загружен датасет, а так же подготовлены отдельные массивы данных для обучения и тестирования. Датасет собран для пары EURUSD за период с начала 2015 года до сегодняшнего дня, шаг сбора данных — свеча M6. Последние 2 недели — тестовый участок. Данные в датасете — это набор из сотен тысяч строк каждая из которых примерно такая
```
0.32,0.26,0.00,0.43 ... 0.66,0.25,0.24,0.05,0,1,1600144440,1.189240
```
Предикторы идут через запятую, поля 3 и 4 с конца — это правильный ответ куда пошел тренд (0,1 — вниз; 1,0 — вверх). Второе поле с конца — id свечи. Последнее — цена на открытии свечи. Для обучения последние два поля не используются.
### 3. Обучение и тестирование модели
При первом запуске оставьте настройки нейросети по умолчанию. Обучение будет проходить в пять заходов пока не будет получен приемлемый результат. В случае успешного обучения появится примерно такая таблица:
```
+------------+---------+----------+-------------+------------+
| Ответ сети | Выиграл | Проиграл | Выиграл (%) | Сигналов (%)
+------------+---------+----------+-------------+------------+
| 0 | 7174 | 7173 | 50 | 100.0 |
| 2 | 6956 | 6731 | 50 | 95.4 |
| 4 | 6430 | 6224 | 50 | 88.2 |
| 6 | 5867 | 5630 | 51 | 80.1 |
| 8 | 5250 | 5065 | 50 | 71.9 |
| 10 | 4636 | 4450 | 51 | 63.3 |
| 12 | 3964 | 3772 | 51 | 53.9 |
| 14 | 3330 | 3152 | 51 | 45.2 |
| 16 | 2758 | 2539 | 52 | 36.9 |
| 18 | 2198 | 2012 | 52 | 29.3 |
| 20 | 1700 | 1544 | 52 | 22.6 |
| 22 | 1298 | 1167 | 52 | 17.2 |
| 24 | 958 | 825 | 53 | 12.4 |
| 26 | 699 | 517 | 57 | 8.5 |
| 28 | 446 | 278 | 61 | 5.0 |
| 30 | 246 | 127 | 65 | 2.6 |
+------------+---------+----------+-------------+------------+
```
Ответ нейросети — это бинарная классификация где [0 1] это «вниз», а [1 0] — «вверх». Но нейросеть никогда не отвечает целым значением, ее ответ, в зависимости от степени «уверенности», может быть типа [0.4 0.6]. В таком ответе нейросеть считает, что цена пойдет вниз, но не очень уверенна, а в ответе [0.1 0.9] тоже вниз, но уверенности намного больше. Вот как выглядит массив реальных ответов:
```
[[0.5084921 0.49150783]
[0.3930727 0.6069273 ]
[0.4930727 0.50692725]
...
[0.5189831 0.48101687]
[0.27955987 0.7204401 ]
[0.476914 0.5230861 ]]
```
Поле таблицы «Ответ сети» — это разница внутри этого бинарного ответа умноженная на 100. Очевидно, что эта разница характеризует «уверенность» сети в своем прогнозе. В итоге, после умножения на 100, мы имеем значения в диапазоне от 0 до 100. Теперь можно брать не все ответы, а выбирать только те, в которых нейросеть имеет значимую «уверенность». Что бы понять на сколько ответ влияет на результат прогноза, тестовый участок проверяется на правильность прогноза при разных уровнях этой «уверенности». Каждая строка таблицы — это проверка при новом большем значении «Ответа сети». Чем выше фильтр «Ответа сети», тем меньше ответов, но тем они качественнее. Это видно по полям «Выиграл» и «Проиграл». Процесс останавливается когда ответов (Сигналов) становится меньше 1% от всех тестовых данных.
Если при одном проходе сеть не обучилась просто перезапустите этот блок (данные заново подгружать не надо).
### 4. Результаты на торговом графике
Запустите этот блок. Тут все очевидно, на графике торговой пары из тестового набора отрисовываются сигналы нейросети, зеленый вверх, красный вниз.
### 5. Тестирование на реальном рынке
При этой проверке подгружаются данные для нейросети которые создаются по ходу добавления новых свечей в реальном времени. Т.е. последняя порция полученных данных создана на открытии свечи, в нашем случае нулевой свечи М6. Эти данные, естественно, не содержат правильного ответа, сети предлагается сделать реальный прогноз. Убедится в том, что данные не подменяются по ходу их движения в историю можно раскомментировав строку print(data) и сравнив значения конкретной строки при входе и спустя некоторое время.
```
def get_from_ennro(symbol, tfm, dim, lim):
...
# print(data)
...
```
Сигналов на реальном рынке может и не быть. Так бывает когда волатильность меньше чем на тестовом участке, в этом случае нейросеть не видит точек для входа.
### Выводы
Да! Качество прогноза не годится для открытия позиций. Но мы такую задачу и не ставили, главное, что нейросеть обучается и что то распознает на графике, угадывает тренд, ее прогноз очевидно не хаотичен. Обратите внимание, что мы использовали простейшую конфигурацию нейросети — Sequential Dense с 2-мя слоями и всего 10 эпох для обучения. Тут есть куда развиваться дальше.
*Продолжение статьи [здесь](https://habr.com/ru/post/562092/).
Добавить нейросеть в MetaTrader5 можно [тут](https://www.mql5.com/ru/blogs/post/746398).* | https://habr.com/ru/post/521960/ | null | ru | null |
# Настраиваем Out-Of-Memory Killer в Linux для PostgreSQL
Когда в Linux сервер базы данных непредвиденно завершает работу, нужно найти причину. Причин может быть несколько. Например, **SIGSEGV** — сбой из-за бага в бэкенд-сервере. Но это редкость. Чаще всего просто заканчивается пространство на диске или память. Если закончилось пространство на диске, выход один — освободить место и перезапустить базу данных.
### Out-Of-Memory Killer
Когда у сервера или процесса заканчивается память, Linux предлагает 2 пути решения: обрушить всю систему или завершить процесс (приложение), который съедает память. Лучше, конечно, завершить процесс и спасти ОС от аварийного завершения. В двух словах, Out-Of-Memory Killer — это процесс, который завершает приложение, чтобы спасти ядро от сбоя. Он жертвует приложением, чтобы сохранить работу ОС. Давайте сначала обсудим, как работает OOM и как его контролировать, а потом посмотрим, как OOM Killer решает, какое приложение завершить.
Одна из главных задач Linux — выделять память процессам, когда они ее просят. Обычно процесс или приложение запрашивают у ОС память, а сами используют ее не полностью. Если ОС будет выдавать память всем, кто ее просит, но не планирует использовать, очень скоро память закончится, и система откажет. Чтобы этого избежать, ОС резервирует память за процессом, но фактически не выдает ее. Память выделяется, только когда процесс действительно собирается ее использовать. Случается, что у ОС нет свободной памяти, но она закрепляет память за процессом, и когда процессу она нужна, ОС выделяет ее, если может. Минус в том, что иногда ОС резервирует память, но в нужный момент свободной памяти нет, и происходит сбой системы. OOM играет важную роль в этом сценарии и завершает процессы, чтобы уберечь ядро от паники. Когда принудительно завершается процесс PostgreSQL, в логе появляется сообщение:
```
Out of Memory: Killed process 12345 (postgres).
```
Если в системе мало памяти и освободить ее невозможно, вызывается функция `out_of_memory`. На этом этапе ей остается только одно — завершить один или несколько процессов. OOM-killer должен завершать процесс сразу или можно подождать? Очевидно, что, когда вызывается out\_of\_memory, это связано с ожиданием операции ввода-вывода или подкачкой страницы на диск. Поэтому OOM-killer должен сначала выполнить проверки и на их основе решить, что нужно завершить процесс. Если все приведенные ниже проверки дадут положительный результат, OOM завершит процесс.
### Выбор процесса
Когда заканчивается память, вызывается функция `out_of_memory()`. В ней есть функция `select_bad_process()`, которая получает оценку от функции `badness()`. Под раздачу попадет самый «плохой» процесс. Функция `badness()` выбирает процесс по определенным правилам.
1. Ядру нужен какой-то минимум памяти для себя.
2. Нужно освободить много памяти.
3. Не нужно завершать процессы, которые используют мало памяти.
4. Нужно завершить минимум процессов.
5. Сложные алгоритмы, которые повышают шансы на завершение для тех процессов, которые пользователь сам хочет завершить.
Выполнив все эти проверки, OOM изучает оценку (`oom_score`). OOM назначает `oom_score` каждому процессу, а потом умножает это значение на объем памяти. У процессов с большими значениями больше шансов стать жертвами OOM Killer. Процессы, связанные с привилегированным пользователем, имеют более низкую оценку и меньше шансов на принудительное завершение.
```
postgres=# SELECT pg_backend_pid();
pg_backend_pid
----------------
3813
(1 row)
```
Идентификатор процесса Postgres — 3813, поэтому в другой оболочке можно получить оценку, используя этот параметр ядра `oom_score`:
```
vagrant@vagrant:~$ sudo cat /proc/3813/oom_score
2
```
Если вы совсем не хотите, чтобы OOM-Killer завершил процесс, есть еще один параметр ядра: `oom_score_adj`. Добавьте большое отрицательное значение, чтобы снизить шансы на завершение дорогого вам процесса.
```
sudo echo -100 > /proc/3813/oom_score_adj
```
Чтобы задать значение `oom_score_adj`, установите OOMScoreAdjust в блоке сервиса:
```
[Service]
OOMScoreAdjust=-1000
```
Или используйте `oomprotect` в команде `rcctl`.
```
rcctl set *servicename* oomprotect -1000
```
### Принудительное завершение процесса
Когда один или несколько процессов уже выбраны, OOM-Killer вызывает функцию `oom_kill_task()`. Эта функция отправляет процессу сигнал завершения. В случае нехватки памяти `oom_kill()` вызывает эту функцию, чтобы отправить процессу сигнал SIGKILL. В лог ядра записывается сообщение.
```
Out of Memory: Killed process [pid] [name].
```
### Как контролировать OOM-Killer
В Linux можно включать и отключать OOM-Killer (хотя последнее не рекомендуется). Для включения и отключения используйте параметр `vm.oom-kill`. Чтобы включить OOM-Killer в среде выполнения, выполните команду `sysctl`.
```
sudo -s sysctl -w vm.oom-kill = 1
```
Чтобы отключить OOM-Killer, укажите значение 0 в этой же команде:
```
sudo -s sysctl -w vm.oom-kill = 0
```
Результат этой команды сохранится не навсегда, а только до первой перезагрузки. Если нужно больше постоянства, добавьте эту строку в файл `/etc/sysctl.conf`:
```
echo vm.oom-kill = 1 >>/etc/sysctl.conf
```
Еще один способ включения и отключения — написать переменную `panic_on_oom`. Значение всегда можно проверить в `/proc`.
```
$ cat /proc/sys/vm/panic_on_oom
0
```
Если установить значение 0, то когда закончится память, kernel panic не будет.
```
$ echo 0 > /proc/sys/vm/panic_on_oom
```
Если установить значение 1, то когда закончится память, случится kernel panic.
```
echo 1 > /proc/sys/vm/panic_on_oom
```
OOM-Killer можно не только включать и выключать. Мы уже говорили, что Linux может зарезервировать для процессов больше памяти, чем есть, но не выделять ее по факту, и этим поведением управляет параметр ядра Linux. За это отвечает переменная `vm.overcommit_memory`.
Для нее можно указывать следующие значения:
**0:** ядро само решает, стоит ли резервировать слишком много памяти. Это значение по умолчанию в большинстве версий Linux.
**1:** ядро всегда будет резервировать лишнюю память. Это рискованно, ведь память может закончиться, потому что, скорее всего, однажды процессы затребуют положенное.
**2:** ядро не будет резервировать больше памяти, чем указано в параметре `overcommit_ratio`.
В этом параметре вы указываете процент памяти, для которого допустимо избыточное резервирование. Если для него нет места, память не выделяется, в резервировании будет отказано. Это самый безопасный вариант, рекомендованный для PostgreSQL. На OOM-Killer влияет еще один элемент — возможность подкачки, которой управляет переменная `cat /proc/sys/vm/swappiness`. Эти значения указывают ядру, как обрабатывать подкачку страниц. Чем больше значение, тем меньше вероятности, что OOM завершит процесс, но из-за операций ввода-вывода это негативно сказывается на базе данных. И наоборот — чем меньше значение, тем выше вероятность вмешательства OOM-Killer, но и производительность базы данных тоже выше. Значение по умолчанию 60, но если вся база данных помещается в память, лучше установить значение 1.
### Итоги
Пусть вас не пугает «киллер» в OOM-Killer. В данном случае киллер будет спасителем вашей системы. Он «убивает» самые нехорошие процессы и спасает систему от аварийного завершения. Чтобы не приходилось использовать OOM-Killer для завершения PostgreSQL, установите для `vm.overcommit_memory` значение 2. Это не гарантирует, что OOM-Killer не придется вмешиваться, но снизит вероятность принудительного завершения процесса PostgreSQL. | https://habr.com/ru/post/464245/ | null | ru | null |
# Covid-19: зачем мы сидим на карантине, и ответы на другие вопросы
Привет Хабр.
Изначально я не планировал публиковать здесь статью про коронавирус, аналитики на хабре уже более чем достаточно. Однако, читая разные местечковые форумы и соцсети, я с удивлением обнаружил сколько достаточно вредных мифов гуляет в сети, и что обычные люди, не специалисты, в это увы, верят. В итоге, после 10го ответа очередному юзеру на очередное сообщение «коронавирус не хуже гриппа», возникла идея создать FAQ на который можно просто давать ссылку, где бы *понятным простым языком* развенчивались наиболее популярные мифы.
КДПВ не будет, картинка с вирусом уже наверно и так всем надоела.
Статья рассчитана на широкую аудиторию, те кто всё это уже знают, могут не тратить свое время, вряд ли они найдут что-то новое. Я знаю, что многим не нравятся статьи формата «для чайников», но готов рискнуть. Тех кому интересно, приглашаю под кат. Как хабрабонус, в конце будет Python-код для желающих поэкспериментировать с графиками самостоятельно.
> ### Минутка заботы от НЛО
>
>
>
> В мире официально объявлена пандемия COVID-19 — потенциально тяжёлой острой респираторной инфекции, вызываемой коронавирусом SARS-CoV-2 (2019-nCoV). На Хабре много информации по этой теме — всегда помните о том, что она может быть как достоверной/полезной, так и наоборот.
>
>
>
> #### Мы призываем вас критично относиться к любой публикуемой информации
>
>
>
>
> **Официальные источники**
> * [Cайт Министерства здравоохранения РФ](https://covid19.rosminzdrav.ru/)
> * [Cайт Роспотребнадзора](https://www.rospotrebnadzor.ru/about/info/news_time/news_details.php?ELEMENT_ID=13566)
> * [Сайт ВОЗ (англ)](https://www.who.int/emergencies/diseases/novel-coronavirus-2019)
> * [Сайт ВОЗ](https://www.who.int/ru/emergencies/diseases/novel-coronavirus-2019)
> * Сайты и официальные группы оперативных штабов в регионах
>
>
>
> Если вы проживаете не в России, обратитесь к аналогичным сайтам вашей страны.
>
>
> Мойте руки, берегите близких, по возможности оставайтесь дома и работайте удалённо.
>
>
>
> Читать публикации про: [коронавирус](https://habr.com/ru/search/?target_type=posts&q=%5B%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81%5D&order_by=date) | [удалённую работу](https://habr.com/ru/search/?target_type=posts&q=%5B%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%5D&order_by=date)
Итак, приступим. Еще раз повторюсь, все нижеприведенные вопросы я придумал не сам, они были собраны из разных форумов и соц.сетей.
Q1: Это же обычный грипп (на самом деле нет)
--------------------------------------------
Коронавирус это не обычный грипп.
У него в два раза выше репродуктивное число R0 (1.3 против 2-2.5, он в среднем вдвое более заразен), в 4 раза дольше инкубационный период (4 против 14 дней) при котором человек может разносить заразу, в 5-10 раз выше процент госпитализации, и где-то в 10 раз выше летальность. Каждый фактор по отдельности уже сам по себе неприятен, но объединяя всё это вместе, мы получаем достаточно убойную штуку, в прямом смысле этого слова.
Q2: А-а-а, мы все умрем, смертность 21% (на самом деле нет)
-----------------------------------------------------------
Не менее вредный миф чем предыдущий. Многие открывают [www.worldometers.info/coronavirus](https://www.worldometers.info/coronavirus/) и видят такую картину:
Цифра в 21% приводит в ужас неподготовленного обывателя. Однако, на самом деле, данная цифра не имеет ничего общего с летальностью от covid.
Рассмотрим простой пример. Допустим, заразилось вирусом 100 человек. Из них 50% переболело бессимптомно, вообще не пошли к врачу и в статистику не попали. Из оставшихся 50, 20 переболели в легкой форме, и им поставили диагноз ОРВИ. Другие 30 попали в больницу, из них 5 получили диагноз «пневмония», остальные 25 получили реальные тесты на covid. В итоге, из этих 25 допустим, 3 умерло. Результат: в официальную статистику worldometers попадет «22 выздоровело, 3 умерло, 12% смертей». Вопрос — какое отношение эти 12% имеют к реальной летальности от коронавируса? Правильно, никакое. Я вообще сомневаюсь, что у этой цифры есть какой-то физический смысл, это скорее показатель доступности тестов для населения в той или иной стране. А тестов кстати везде не хватает, не только в России, но и в США или UK ситуация аналогична.
Примерная летальность от Covid составляет по разным оценкам, 0.5-3%. Это тоже много, но никак не 21%. Более того, по статистике около 50% случаев проходят вообще в бессимптомной форме, а для человека 40-50 лет летальность составляет [порядка 0.4%](https://www.worldometers.info/coronavirus/coronavirus-age-sex-demographics/).
Q3: Смертность и летальность
----------------------------
Уже обсуждалось не раз, но множество людей до сих пор путает.
*Смертность*: количество смертей на 1000 человек населения в год. Используется скорее как показатель качества системы здравоохранения, типа «в Уганде от диареи умирает 10 человек в год», или «смертность от рака в Израиле ниже чем в России».
*Летальность*: отношение числа умерших к числу переболевших, именно этот параметр обычно и интересует большинство. Но и тут есть нюанс, т.к. точное число переболевших *неизвестно*, то точная летальность коронавируса пока неизвестна тоже, см. предыдущий пункт.
Q4: Зачем в России вводить карантин, если смертей так мало?
-----------------------------------------------------------
Для ответа на этот вопрос совместим кривую числа заболевших для разных стран.
Из этого графика можно сделать два вывода:
* Скорость роста числа заболевших примерно одинакова. Россия увы, не исключение.
* Важный момент — график по вертикали логарифмический. Это значит что одна клетка соответствует **увеличению в 10 раз** — 100, 1000, 10000, 100000 и т.д. Действительно, любой желающий может зайти на [covid.2gis.ru](https://covid.2gis.ru) и убедиться, что в среднем число больных *удваивается* каждые 4 дня.
В итоге, ответ простой — карантин вводится для того, чтобы *предотвратить будущие смерти*, даже если сейчас их мало. И это по большому счету, определенная удача что в России/Украине/Беларуси можно учиться на чужих ошибках, а не на своих, т.к. эпидемия началась позже. Понятно, что 3 умерших за 2 недели в Петербурге от коронавируса, это «не внушает», но надо понимать, что если *ничего не делать*, то 3 легко превратится в 30, потом в 300 и т.д.
Q5: Карантин не работает
------------------------
Это неверно. Во-первых, карантин не может не работать. Если мы уменьшаем число контактов, то и шансов распространиться у вируса тоже меньше, если конечно люди этот карантин соблюдают, а не едут компанией на шашлыки или к родственникам.
Во-вторых, важно иметь в виду, что результаты карантина видны не сразу, а через 2-3 недели. Это связано с инкубационным периодом, и с тем что тестируют обычно не сразу, а тех кто уже с ухудшением состояния попадает в больницу.
Посмотрим графики новых случаев в день по разным странам, где был введен карантин:
На всех графиках четко виден момент «перелома», когда экспоненциальный рост удвоения случаев каждые несколько дней сменяется линейным, а затем и снижением. В России на момент написания статьи прошло слишком мало дней с введения карантина, так что данных пока нет. Но то, что число новых случаев будет снижаться, сомнений не вызывает.
Q6: Когда карантин закончится?
------------------------------
По идее, тогда, когда число *новых случаев в день* будет стабильно падать. К сожалению, никакой удобной для просмотра инфографики на официальных российских сайтах мне не попадалось, так что проверять удобнее всего на [www.worldometers.info/coronavirus/country/russia](https://www.worldometers.info/coronavirus/country/russia/), параметр «Daily New Cases».
Но важно иметь в виду, что вакцину обещают не раньше чем через год, а реальное число переболевших пока что не более 1%, так что какие-то ограничения вероятно сохранятся надолго. Это важно, например при планировании бизнеса, связанного с массовыми мероприятиями.
Q7: Коронавирус был придуман в США/Израиле/России/etc
-----------------------------------------------------
Это неверно. Геном коронавируса уже расшифрован, его происхождение из Китая сомнений не вызывает. Интерактивные данные можно посмотреть здесь: [www.gisaid.org/epiflu-applications/next-hcov-19-app](https://www.gisaid.org/epiflu-applications/next-hcov-19-app/)
Q8: Вирус давно с нами, им все уже переболели
---------------------------------------------
Это к сожалению, неверно. Действительно, около 50% случаев covid по статистике проходят бессимптомно, а 80% не требуют госпитализации, и много таких случаев не тестировалось, но говорить о «коллективном иммунитете» пока не приходится. По [оценкам](https://www.imperial.ac.uk/media/imperial-college/medicine/sph/ide/gida-fellowships/Imperial-College-COVID19-Europe-estimates-and-NPI-impact-30-03-2020.pdf) английского Imperial College от 30 марта, примерное число инфицированных может колебаться от 15% в Испании, 9% в Италии до 3% во Франции или 0.5% в Норвегии:
По России таких оценок найти не удалось, но вряд ли они кардинально отличаются.
Кстати, относительно уже переболевших, остаются два важных вопроса. Первый, это возможность повторного заражения. Вопрос пока открыт, но такая вероятность считается [крайне малой](https://ria.ru/20200319/1568817611.html). Второй вопрос — как узнать, переболел человек ранее или нет. Для этого разрабатываются специальные тесты на антитела, которые уже [начали использоваться](https://ria.ru/20200405/1569590779.html). Насчет их доступности в России, на момент написания статьи данных пока нет.
Исходные данные
---------------
CSV-файлы для самостоятельного анализа можно взять из репозитория COVID-19 github-аккаунта университета Джонса Хопкинса: [github.com/CSSEGISandData/COVID-19](https://github.com/CSSEGISandData/COVID-19).
Для желающих поэкспериментировать, исходный код под спойлером.
**Код для Python 3.7**
```
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.ticker import FormatStrFormatter, StrMethodFormatter, ScalarFormatter, FuncFormatter
# Load the dataset.
# Source https://github.com/CSSEGISandData/COVID-19/blob/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv
df = pd.read_csv('covid19_confirmed_global.csv')
# print(df)
def get_data(country: str):
df_ = df.loc[(df['Country/Region'] == country) & (df['Province/State'].isnull())]
df_data = df_.loc[:, '1/22/20':'4/4/20']
values = df_data.values.tolist()[0]
new_cases = df_data.diff(axis=1).values.tolist()[0][1:]
# Shift data to axis beginning
treshold = 20
start_index = values.index(next(filter(lambda x: x >= treshold, values)))
return values[start_index:], new_cases[start_index:]
values_rus, values_rus_daily = get_data('Russia')
values_ita, values_ita_daily = get_data('Italy')
values_uk, values_uk_daily = get_data('United Kingdom')
values_ger, values_ger_daily = get_data('Germany')
values_spa, values_spa_daily = get_data('Spain')
values_fin, values_fin_daily = get_data('Finland')
fig, ax = plt.subplots()
fig.set_size_inches(12, 5)
# Draw
total_cases, new_cases = True, False
# 1. Total cases
if total_cases:
ax.semilogy()
ax.get_yaxis().set_major_formatter(ScalarFormatter())
ax.plot(values_rus, label='Россия')
ax.plot(values_ita, label='Италия')
ax.plot(values_uk, label='Англия')
ax.plot(values_ger, label='Германия')
ax.plot(values_spa, label='Испания')
ax.plot(values_fin, label='Финляндия')
plt.xlabel('Дни')
plt.ylabel('Общее число случаев')
# Daily new cases
if new_cases:
fig.set_size_inches(12, 5)
plt.grid(False)
ax.bar(range(len(values_rus_daily)), values_rus_daily, width=0.6, label='Россия')
# ax.bar(range(len(values_ita_daily)), values_ita_daily, width=0.9, label='Италия')
# ax.bar(range(len(values_spa_daily)), values_spa_daily, width=0.9, label='Испания')
# ax.bar(range(len(values_uk_daily)), values_uk_daily, width=0.7, label='Англия')
# ax.bar(range(len(values_ger_daily)), values_ger_daily, width=0.8, label='Германия')
plt.xlabel('Дни')
plt.ylabel('Случаи в день')
plt.legend(loc='upper left')
plt.show()
```
Заключение
----------
Всем спасибо, кто дочитал досюда. Если другие продолжат тему «разрушения мифов», было бы неплохо. Если есть какие-то еще интересные вопросы, пишите в комментариях, добавлю.
PS: И напоследок, в комментариях попросили «не нагнетать», так что добавлю немного позитива. По параметру «количества смертей на миллион» Россия на данный момент имеет весьма хорошие показатели (0.3, для сравнения со 124 во Франции или 73 в Англии), да и карантин здесь был введен раньше чем в других странах. Так что есть достаточно высокая вероятность, что в России эту эпидемию действительно удастся пройти вообще без каких-либо существенных потерь. | https://habr.com/ru/post/495828/ | null | ru | null |
# FreeBSD Netgraph на примере Ethernet тоннеля
Всем привет.
Думаю многим системным администраторам, работающим с FreeBSD, известно о существовании ядерной подсистемы Netgraph. Но не многие знают/понимают как это работает, и что из этого можно построить.
Расскажу что это такое, а также разберу на простом примере сборку Ethernet моста через интернет.
### Немного теории.
Википедия рассказывает [http://ru.wikipedia.org/wiki/Netgraph](http://ru.wikipedia.org/wiki/Netgraph "Википедия")
*Netgraph — модульная сетевая подсистема ядра FreeBSD, основанная на принципе графов. В Netgraph строится граф из узлов различных типов, узел каждого типа имеет некоторое количество входов/выходов (далее хуков (hooks)). Узел netgraph позволяет производить определенные действия над пакетом, проходящим через него. Некоторые Netgraph узлы предоставляют поддержку различных протоколов, инкапсуляций, таких как L2TP, PPTP, PPPoE, PPP, ATM, bluetooth, другие служат для связки модулей и сортировки/маршрутизации между узлами netgraph, например bpf, split.*
Подсистема Netgraph представляет собой набор модулей, каждый со своей специфичной задачей. Это такая горстка кубиков лего, которые всегда можно соединить.
Ярким примером использования множества netgraph модулей является массово используемый мелкими Российскими провайдерами демон [mpd](http://mpd.sourceforge.net/ "Демон MPD"), для терминации клиентских туннелей, таких как PPPoE, PPTP, PPP и т.п. В версиях 3 ветки mpd многие операции делал сам, а к 5 текущей версии в основном занимается коммутацией модулей netgraph.
### Посмотрим на наши кубики.
`[root@bsd1] /boot/kernel/> ls | grep ng_
ng_UI.ko
ng_async.ko
ng_atm.ko
ng_atmllc.ko
ng_bluetooth.ko
ng_bpf.ko
ng_bridge.ko
ng_bt3c.ko
ng_btsocket.ko
ng_car.ko
ng_ccatm.ko
ng_cisco.ko
ng_deflate.ko
ng_device.ko
ng_echo.ko
ng_eiface.ko
ng_etf.ko
ng_ether.ko
ng_fec.ko
ng_frame_relay.ko
ng_gif.ko
ng_gif_demux.ko
ng_h4.ko
ng_hci.ko
ng_hole.ko
ng_hub.ko
ng_iface.ko
ng_ip_input.ko
ng_ipfw.ko
ng_ksocket.ko
ng_l2cap.ko
ng_l2tp.ko
ng_lmi.ko
ng_mppc.ko
ng_nat.ko
ng_netflow.ko
ng_one2many.ko
ng_ppp.ko
ng_pppoe.ko
ng_pptpgre.ko
ng_pred1.ko
ng_rfc1490.ko
ng_socket.ko
ng_source.ko
ng_split.ko
ng_sppp.ko
ng_sscfu.ko
ng_sscop.ko
ng_sync_ar.ko
ng_sync_sr.ko
ng_tag.ko
ng_tcpmss.ko
ng_tee.ko
ng_tty.ko
ng_ubt.ko
ng_uni.ko
ng_vjc.ko
ng_vlan.ko
[root@bsd1] /boot/kernel/> ls | grep ng_ | wc -l
58
[root@bsd1] /boot/kernel/>`
На данный момент 58 модулей +1 основной модуль netgraph.ko (FreeBSD 7.3). Все они могут быть собраны в ядро статически, или загружены динамически. Т.к модули ядерные, работают они тоже прямо в ядре, за счет чего можно получить поразительные по производительности результаты.
Для каждого модуля существует man, в котором описываются возможности модуля, входы/выходы (hook, крючки, зацепки, далее буду называть их «хуками»), принимаемые контрольные сообщения и их действия.
Для управления подсистемой netgraph существует утилита ngctl воспринимающая разные команды, такие как list,mkpeer,connect,name и др., про них отдельно можно прочитать в man ngctl.
### Задача.
Поставим простую задачу: необходимо соединить две физических сети Ethernet через интернет.
Имеем 2 сервера.
BSD1
2 сетевых интерфейса
Интерфейс 1 em0 — внешний IP 1.1.1.1
Интерфейс 2 em1 — внутренний IP 192.168.1.1
BSD2
2 сетевых интерфейса
Интерфейс 1 em0 — внешний IP 2.2.2.2
Интерфейс 2 em1 — внутренний IP 192.168.1.2
Между серверами имеется маршрутизируемая интернет связь через внешние интерфейсы.
Соединить нужно сети на интерфейсах em1 обоих серверов.
### Посмотрим на наши кубики.
Нам потребуются:
**netgraph.ko** — основа.
 **ng\_ether.ko** — модуль подключения к физическим сетевым интерфейсам. При загрузке этого модуля в пространстве графов автоматически создаются по одному узлу на каждый физический интерфейс, имеющих имя этого интерфейса. В нашем случае это будут «em0:», «em1:». Каждый узел ng\_ether имеет 3 хука: lower, upper, orphans. Хук lower — это прямой выход в место драйвера сетевого интерфейса, откуда пакеты отправляются или принимаются устройством. Хук upper это прямой выход в место ядра системы, откуда пакеты должны отправляться или приниматься драйвером сетевого устройства. Хук orphans, это тот же lower, только в него попадают ошибочные, испорченные пакеты с сетевого устройства. Его во внимание не берем.
Если сказать простым языком: при подключении ng\_ether в обмене между ядром и драйвером сетевой карты появляется разрыв. Со стороны ядра этот разрыв называется upper, со стороны драйвера сетевого устройства lower. Этот разрыв соединен, до момента когда к lower или upper не подключится что-нибудь из подсистемы netgraph.
 **ng\_bridge.ko** — модуль самого настоящего Ethernet свитча. Все, думаю, могут представить (а кто-то и сейчас видит), коробочку с Ethernet портами, моргающую лампочками, стоящую на столе и объединяющую компьютеры в сеть. ng\_bridge — та самая коробочка в подсистеме netgraph. ng\_bridge — простая реализация Ethernet свитча, снабженная arp таблицей и простым алгоритмом определения петель. Хуки ng\_bridge именуются link0, link1 и т.д. К ним мы и будем подключать хуки наших ng\_ether. Модуль принимает контрольные сообщения, такие как setconfig, getconfig, reset, getstats, clrstats, getclrstats, gettable. Действия сообщений интуитивно понятны, подробности в man ng\_bridge.
 **ng\_ksocket.ko** — модуль, позволяющий открыть на прослушку сокет прямо из ядра (любой сокет, поддерживаемый системной функцией socket()), и подключиться к другому сокету. Принимает единственное подключение к хуку "//". В man socket рассказано какие бывают family, type, proto. В нашем случае это будет «inet/dgram/udp». inet — ipv4, dgram — дейтаграммы, proto — udp. Так же модуль принимает несколько контрольных сообщений, такие как bind, listen, connect, accept, getname, getpeername, setopt, getopt. Подробнее можно прочитать в man ng\_ksocket. Используя сообщение «connect» мы можем подключить наш входящий хук «inet/dgram/udp» к удаленному, который был создан аналогично, но командой «bind».
### Составляем граф.
Для лучшего понимания работы вашей системы графов, перед сборкой в системе желательно их нарисовать.
1. Подключаем оба хука модуля ng\_ether интерфейса em1 к ng\_bridge, чтобы система видела и физическую сеть, подключенную к интерфейсу, и нашу виртуальную. Делается одинаково на обоих серверах.
2. Следующий свободный линк ng\_bridge подключаем к ng\_ksocket с параметрами inet/dgram/udp. (Почему я выбрал UDP? Потому что никто не гарантирует успешную доставку сигнала в кабеле или радио сети, так же как аналогично в IP протоколе никто не гарантирует доставку UDP.) Делается одинаково на обоих серверах.
3. Командуем модулю ng\_ksocket занять определенный порт, на определенном IP адресе, а так же подключиться к удаленному IP по нужному порту. Делаем это на обоих серверах, в том отличии, что меняются IP адреса и порты на противоположные друг другу.
### Собираем граф в системе.
Выше я уже упомянул об утилите ngctl. С её помощью мы создадим наши модули в системе и свяжем их.
Нам потребуются команды mkpeer, connect, name, msg. Опишу их простым языком.
**Команда mkpeer.**
Синтаксис: *ngctl mkpeer модуль1 тип\_модуля2 хук1 хук2*
Создает «модуль2» с указанным типом и подключает его хук «хук2» к «хук1» модуля «модуль1»
**Команда connect.**
Синтаксис: *ngctl connect модуль1 модуль2 хук1 хук2*
Подключает «хук1» модуля «модуль1» к «хук2» модуля «модуль2».
**Команда name.**
Синтаксис: *ngctl name модуль: хук имя*
Присваивает имя созданному через mkpeer модулю.
**Команда msg.**
Синтаксис: *ngctl msg модуль: сообщение параметры*
Передает контрольное «сообщение» в «модуль» с «параметрами».
Ну а теперь как будет выглядеть наш граф в живую для сервера «bsd1». Для тоннеля будем использовать udp порт 7777
Создаем узел ng\_bridge и подключаем к его хуку «link0» хук сетевого интерфейса «em1» «lower».
**ngctl mkpeer em1: bridge lower link0**
Называем только что созданный узел именем «switch», его можно найти по пути «em1:lower».
**ngctl name em1:lower switch**
Подключаем к «link1» нашего «switch» upper сетевого интерфейса «em1».
**ngctl connect switch: em1: link1 upper**
Создаем узел ng\_ksocket и подключаем к его хуку «inet/dgram/udp» «link2» нашего «switch»
**ngctl mkpeer switch: ksocket link2 inet/dgram/udp**
Называем только что созданный ksocket «switch\_socket», его можно найти по пути «switch:link2»
**ngctl name switch:link2 switch\_socket**
Отправляем команду «bind» нашему «switch\_socket», с параметрами. ksocket займет порт 7777 на IP 1.1.1.1.
**ngctl msg switch\_socket: bind inet/1.1.1.1:7777**
Отправляем команду «connect» нашему «switch\_socket», с параметрами. ksocket подключится к порту 7777 по IP адресу 2.2.2.2.
**ngctl msg switch\_socket: connect inet/2.2.2.2:7777**
Отправляем команду модулю ng\_ether сетевого интерфейса em1 перейти в режим прослушки пакетов, адресованных не ему. Нам ведь теперь необходимо принимать пакеты для устройств находящихся в нашей виртуальной сети.
**ngctl msg em1: setpromisc 1**
**ngctl msg em1: setautosrc 0**
Для сервера «bsd2» нам лишь нужно поменять параметры команд bind и connect местами.
Для простоты использования всё это я оформил в sh скрипт.
В скрипте используется ещё одна команда ngctl shutdown. Эта команда посылает специальное контрольное сообщение модулю, указанному в параметре. Это сообщение принимает каждый модуль, подробнее в «man модуль». Обычно эта команда вызывает уничтожение модуля и разрыв всех его связей.
```
#!/bin/sh
self=1.1.1.1
peer=2.2.2.2
port=7777
if=em1
case "$1" in
start)
echo "Starting netgraph switch."
ngctl mkpeer ${if}: bridge lower link0
ngctl name ${if}:lower switch
ngctl connect switch: ${if}: link1 upper
ngctl mkpeer switch: ksocket link2 inet/dgram/udp
ngctl name switch:link2 switch_socket
ngctl msg switch_socket: bind inet/${self}:${port}
ngctl msg switch_socket: connect inet/${peer}:${port}
ngctl msg ${if}: setpromisc 1
ngctl msg ${if}: setautosrc 0
echo "Ok."
exit 0
;;
stop)
echo "Stopping netgraph switch."
ngctl shutdown switch_socket:
ngctl shutdown switch:
ngctl shutdown ${if}:
echo "Ok."
exit 0
;;
restart)
sh $0 stop
sh $0 start
;;
*)
echo "Usage: `basename $0` { start | stop | restart }"
exit 64
;;
esac
```
Посмотрим что получилось
`[root@bsd1] /usr/local/etc/rc.d/> ngctl list
There are 5 total nodes:
Name: em0 Type: ether ID: 00000001 Num hooks: 0
Name: em1 Type: ether ID: 00000002 Num hooks: 2
Name: switch Type: bridge ID: 000000f6 Num hooks: 3
Name: ngctl16408 Type: socket ID: 00000100 Num hooks: 0
Name: switch_socket Type: ksocket ID: 000000fa Num hooks: 1`
Модуль «ngctl16408» с типом socket используется ngctl для управления, не обращайте на него внимания.
Пакетики бегут:
```
[root@bsd1] /root/> ping 192.168.1.2
PING 192.168.1.2 (192.168.1.2): 56 data bytes
64 bytes from 192.168.1.2: icmp_seq=0 ttl=64 time=3.760 ms
64 bytes from 192.168.1.2: icmp_seq=1 ttl=64 time=3.527 ms
64 bytes from 192.168.1.2: icmp_seq=2 ttl=64 time=3.479 ms
64 bytes from 192.168.1.2: icmp_seq=3 ttl=64 time=4.052 ms
[root@bsd1] /root/> ngctl msg switch: getstats 2
Rec'd response "getstats" (4) from "[f6]:":
Args: { recvOctets=49333 recvPackets=532 recvMulticast=467 recvBroadcast=63 xmitOctets=580 xmitPackets=12 xmitMulticasts=10 xmitBroadcasts=1 }
```
### Конец
Написал много текста, надеюсь, доступного для понимания. На практике такой тоннель кому-то покажется не защищенным, т.к пакетики будут бегать в открытом виде по интернету, но никто не мешает вам пробросить этот тоннель внутри VPN соединения. Я, например, такую связку использую для проброса IPTV мультикаста в рабочую сеть.
В следующей статье опишу ещё несколько модулей netgraph — считалку трафика ng\_netflow, нат ng\_nat, добавим к получившейся сегодня схеме шейпинг через ng\_car, а может быть придумаю еще чего-нибудь интересного.
Спасибо за внимание. | https://habr.com/ru/post/86553/ | null | ru | null |
# Добавляем Pattern Matching и параметризованные методы в Objective-C
Все больше и больше статей на тему «добавь функциональные ~~косты~~ плюшки в свой любимый императивный язык программирования». [Вот недавний пример для Java](http://habrahabr.ru/blogs/java/122919/).
В Objective-C не так давно были добавлены блоки (blocks), с помощью которых реализованы замыкания. Но хочется чего-то большего. Например сопоставления с образом ([Pattern Matching](http://en.wikipedia.org/wiki/Pattern_matching)) и параметризованные методы.
Исключительно Just For Fun попробуем добавить их в язык без патчинга компилятора и танцев с препроцессором, только средствами самого языка.
Что из этого получилось?
Все описанное далее исключительно пример иллюстрирующий идею и использование его в своих проектах вы можете на свой страх и риск.
Cопоставление с образом позволяет написать что-то на подобии:
`factorial( 0 ) -> 1
factorial( 1 ) -> 1
factorial( n ) -> n * factorial( n - 1 )`
Для начала, пробуем сделать сопоставление с образом. Итак, создаем расширение NSObject и объявляем тип блока, в который мы и будем заворачивать дополнительные реализации.
> typedef id (^PatternMatchingBlock)(id obj);
>
>
>
> @interface NSObject (PatternMatching)
>
> -(void)method:(SEL)sel\_ withParameter:(id)object\_ useBlock:(PatternMatchingBlock)block\_;
>
> @end
Теперь нужно подменить реализацию селектора чтобы иметь возможность выбирать необходимую реализацию в зависимости от переданного фактического параметра. В этом поможет прием подмены метода ([Method Swizzling](http://www.cocoadev.com/index.pl?MethodSwizzling)). Каждый метод — это структура типа `objc_method` из которой нас интересует поле `method_imp` типа `IMP`. `IMP` — это указатель на C-функцию реализации метода. Смысл подмены метода — в замене этих указателей у 2-х методов. Создаем класс, который будет хранить в себе указатель на изначальную реализацию метода и словарь, ключами которого будут объекты «образов», а значениями — блоки реализаций:
> @interface PMImplementation : NSObject
>
> @property ( nonatomic, retain ) NSMutableDictionary\* impls;
>
> @property ( nonatomic, retain ) NSValue\* defaultImpl;
>
> +(id)implementationWithDefaultImpl:(IMP)impl\_;
>
> -(id)forObject:(id)object\_ invokeWithParameter:(id)parameter\_;
>
> @end
>
>
>
> static char\* PMimplsKey = nil;
>
>
>
> @implementation PMImplementation
>
> @synthesize impls = \_impls;
>
> @synthesize defaultImpl = \_default\_impl;
>
> -(void)dealloc {
>
> [\_impls release];
>
> [\_default\_impl release];
>
> [super dealloc];
>
> }
>
> -(id)initWithDefaultImpl:(IMP)impl\_ {
>
> if ( !(self = [super init]) )
>
> return nil;
>
> self.defaultImpl = [NSValue valueWithPointer:impl\_];
>
> self.impls = [NSMutableDictionary dictionary];
>
> return self;
>
> }
>
> +(id)implementationWithDefaultImpl:(IMP)impl\_ {
>
> return [[[self alloc] initWithDefaultImpl:impl\_] autorelease];
>
> }
>
> -(id)forObject:(id)object\_ invokeWithParameter:(id)parameter\_ {
>
> for( id key\_ in [self.impls allKeys] )
>
> if ( [key\_ isEqual:parameter\_] ) {
>
> PatternMatchingBlock block\_ = [self.impls objectForKey:key\_];
>
> return block\_( parameter\_ );
>
> }
>
> IMP impl\_ = [self.defaultImpl pointerValue];
>
> return impl\_(object\_, \_cmd, parameter\_);
>
> }
>
> @end
И собственно реализация расширения NSObject:
> @implementation NSObject (PatternMatching)
>
> -(NSMutableDictionary\*)impls{
>
> NSMutableDictionary\* impls\_ = objc\_getAssociatedObject(self, &PMImplsKey);
>
> if ( !impls\_ ) {
>
> impls\_ = [NSMutableDictionary dictionary];
>
> objc\_setAssociatedObject(self, &PMImplsKey, impls\_
>
> , OBJC\_ASSOCIATION\_RETAIN\_NONATOMIC);
>
> }
>
> return impls\_;
>
> }
>
> -(void)method:(SEL)sel\_ withParameter:(id)object\_
>
> useBlock:(PatternMatchingBlock)block\_ {
>
> NSString\* selector\_key\_ = NSStringFromSelector(sel\_);
>
> PMImplementation\* impl\_ = [self.impls objectForKey:selector\_key\_];
>
> if ( !impl\_ ) {
>
> Method default\_ = class\_getInstanceMethod([self class], sel\_);
>
> IMP default\_impl\_ = method\_getImplementation(default\_);
>
> impl\_ = [PMImplementation implementationWithDefaultImpl:default\_impl\_];
>
> [self.impls setObject:impl\_ forKey:selector\_key\_];
>
> Method swizzed\_method\_ = class\_getInstanceMethod([self class]
>
> ,@selector(swizzledMethod:));
>
> method\_setImplementation(default\_, method\_getImplementation(swizzed\_method\_));
>
> }
>
> [impl\_.impls setObject:block\_ forKey:object\_];
>
> }
>
>
>
> -(id)swizzledMethod:(id)obj\_ {
>
> PMImplementation\* impl\_ = [self.impls objectForKey:NSStringFromSelector(\_cmd)];
>
> return [impl\_ forObject:self invokeWithParameter:obj\_];
>
> }
>
> @end
Вся магия — в методе [-NSObject method:withParameter:useBlock:]. Для переданного селектора мы создаем объект PMImplementation, который сохраняет в себе указатель на реализацию. После чего заменяем его на метод «swizzledMethod:». Трюк в том, что мы можем узнать какой селектор был вызван на самом деле через параметр \_cmd, который неявно передается при вызове любого селектора. Теперь при вызове swizzledMethod вызывается [-PMImplementation forObject:invokeWithParameter:] а там мы уже либо находим по объекту блок и выполняем его, либо используем реализацию по умолчанию.
Метод [-NSObject impls] добавляет в рантаме для self словарь, хранящий объекты PMImplementation для разных селекторов.
Теперь то, ради всего все это затевалось — например класс для нахождения факториала:
> @interface Factorial : NSObject
>
> -(NSDecimalNumber\*)factorial:( NSDecimalNumber\* )number\_;
>
> @end
>
>
>
> @implementation Factorial
>
> -(id)init {
>
> if ( !( self = [super init] ) )
>
> return nil;
>
>
>
> NSDecimalNumber\* zero\_ = [NSDecimalNumber numberWithInteger:0];
>
> [self method:@selector(factorial:) withParameter:zero\_ useBlock: ^(id obj\_){
>
> return (id)[NSDecimalNumber numberWithInteger:1];
>
> }];
>
> NSDecimalNumber\* one\_ = [NSDecimalNumber numberWithInteger:1];
>
> [self method:@selector(factorial:) withParameter:one\_ useBlock: ^(id obj\_){
>
> return (id)[NSDecimalNumber numberWithInteger:1];
>
> }];
>
>
>
> return self;
>
> }
>
> -(NSDecimalNumber\*)factorial:(NSDecimalNumber\*)number\_ {
>
> return [number\_ decimalNumberByMultiplyingBy:
>
> [self factorial:[number\_ decimalNumberBySubtracting:
>
> [NSDecimalNumber numberWithInteger:1]]]];
>
> }
Работает он как и предполагалось:
> Factorial\* factorial\_ = [[Factorial new] autorelease];
>
> NSNumber\* number\_ = [NSDecimalNumber numberWithInteger:10];
>
> NSLog( @"factorial %@ = %@", number\_, [factorial\_ factorial:number\_]);
`factorial 10 = 3628800`
Для параметризации методов напишем небольшой класс-обертку, у которого переопределим метод «isEqual:» и удобный макрос.
> #define PMCLASS( x ) [[[PMClass alloc] initWith:[x class]] autorealese]
>
> @interface PMClass : NSObject
>
> @property ( nonatomic, retain ) Class class;
>
> -(id)initWith:( Class )class\_;
>
> @end
>
>
>
> @implementation PMClass
>
> @synthesize class = \_class;
>
> -(void)dealloc {
>
> [\_class release];
>
> [super dealloc];
>
> }
>
> -(id)initWith:(Class)class\_ {
>
> if ( !( self = [super init] ) )
>
> return nil;
>
> self.class = class\_;
>
> return self;
>
> }
>
> -(BOOL)isEqual:(id)object\_ {
>
> return [self.class isEqual:[object\_ class]];
>
> }
>
> -(id)copyWithZone:(NSZone \*)zone\_ {
>
> return [[PMClass alloc] initWith:self.class];
>
> }
>
> @end
>
>
Теперь реализацию можно выбирать и в зависимости от типа аргумента.
> @interface Test : NSObject
>
> -(void)test:(id)obj\_;
>
> @end
>
>
>
> @implementation Test
>
> -(id)init {
>
> if ( ! (self = [super init] ) )
>
> return nil;
>
> [self method:@selector(test:) withParameter:PMCLASS(NSNull) useBlock:^(id obj\_){
>
> NSLog(@"implementation for Null: %@", [obj\_ class]);
>
> return (id)nil;
>
> }];
>
> return self;
>
> }
>
> -(void)test:(id)obj\_ {
>
> NSLog(@"default impl for Object: %@", [obj\_ class]);
>
> }
>
> @end
Пробуем:
> Test\* test\_ = [[Test new] autorealese];
>
> [test\_ test:@"String"];
>
> [test\_ test:[NSNull null]];
`default impl for Object: NSCFString
implementation for Null: NSNull`
Что можно было сделать еще? Как минимум работу с методами у которых больше одного аргумента, но это сильно бы увеличило статью.
В итоге получены реализации сопоставления с образом и параметризованных методов (правда с жутким синтаксисом) в Objective-C.
Очевидные минусы — в качестве параметров и «образов» можно использовать только объекты.
Надеюсь эта статья была хоть кому-то полезна и после прочтения возникло желание узнать побольше о магии рантайма Objective-C. Если да, то увлекательное чтиво на ночь:
[Objective-C Runtime Programming Guide](http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Introduction/Introduction.html)
[Objective-C Runtime Reference](http://developer.apple.com/library/mac/#documentation/Cocoa/Reference/ObjCRuntimeRef/Reference/reference.html) | https://habr.com/ru/post/123187/ | null | ru | null |
# Как я решил потихоньку учить питон, а попал в дебри CS188.1x Artificial Intelligence
#### Привет Хабр, или введение
Расскажу свою небольшую предысторию.
Как то в очередной раз надоело ковырять очередной контроллер, схему и pcb, и удрученный средней по рынку зарплатой рядового электронщика решил — хочу опять в программисты.
Не могу сказать, что я уже был в программистах, но образование получил 3 года назад по специальности «Информационные системы и технологии» в Военмехе. А судьба занесла в схемотехники-электронщики еще во времена универа. Раньше спасали частые командировки на объекты (пока молод и холост — интересно), а последний год все окончательно надоело.
Читая Хабр, выбрал себе Python.
Эти [первая](http://habrahabr.ru/post/150109/) [вторая](http://habrahabr.ru/post/150302/) недавние статьи помогли определится как и что начинать.
Собственно, по рекомендации и начал в начале сентября с изучения: Марк Лутц. Изучаем Python, 4-е издание. Стиснув зубы и сжав в кулак все что сжималось — на остатке мотивации дочитал до 803-й страницы, сделав попутно все упражнения. На середине ООП меня скрючило окончательно. Книга хороша, но муторна — нет сил.
Просто бросать не хотелось, и дальше попробовал курс [Google’s python class.](http://code.google.com/edu/languages/google-python-class/introduction.html) Ух, как же классно оказалось решить финальную задачку! Два вечера пролетели за мгновенье.
Тут я понял, что дожимать через силу книгу, возможно не лучший вариант. И вспомнил, что видел [пост](http://habrahabr.ru/post/151211/) про курсы западных университетов. Раньше останавливало знание разговорного английского, но ведь Ника Парланте я же понял!
Сказано — сделано, и вот я уже записан на два курса. Про первый уже писали [тут](http://habrahabr.ru/post/152495/), про второй — [тут](http://habrahabr.ru/post/153605/). А то, что в одном python 2.7, в другом 3.2 — еще и лучше, подумалось мне. После дотошного Лутца первые 2 недели обоих курсов щелкнулись как орешки. Отдельное спасибо progress bar за мотивацию. И кликая по ссылкам был найден он — [CS188.1x: Artificial Intelligence](https://www.edx.org/courses/BerkeleyX/CS188.1x/2012_Fall/information/). Что пишут?
> PREREQUISITES
>
> * Programming
>
> 1. Object-Oriented Programming
> 2. Recursion
> 3. Python or the ability to learn Python quickly (short referesher provided)
> * Data Structures
>
> 1. Lists vs. Sets (Arrays, Hashtables)
> 2. Queuing (Stacks, Queues, Priority Queues)
> 3. Trees vs. Graphs (Traversal, Backpointers)
> * Math
>
> 1. Probability, Random Variables, and Expectations (Discrete)
> 2. Basic Asymptotic Complexity (Big-O)
> 3. Basic Counting (Combinations and Permutations)
>
>
>
>
Классно! Вспомню матан, потренирую своего маленького пока еще питона, и ничего что курс идет уже 2ю неделю.
**Полная программа курса**Introduction to AI
* Overview
* Agents: Perception, Decisions, and Actuation
Search and Planning
* Uninformed Search (Depth-First, Breadth-First, Uniform-Cost)
* Informed Search (A\*, Greedy Search)
* Heuristics and Optimality
Constraint Satisfaction Problems
* Backtracking Search
* Constraint Propagation (Forward Checking, Arc Consistency)
* Exploiting Graph Structure
Game Trees and Decision Theory
* Decision Theory
Preferences, Rationality, and Utilities
Maximum Expected Utility
* Game Trees and Tree-Structured Computation
Minimax, Expectimax, Combinations
Evaluation Functions and Approximations
Alpha-Beta Pruning
Markov Decision Processes (MDPs)
* Policies, Rewards, and Values
* Value Iteration
* Policy Iteration
Reinforcement Learning (RL)
* TD/Q Learning
* Exploration
* Approximation
Conclusion and Wrap-Up
No Lecture, Final Exam Week
##### Первое столкновение с действительностью
Расскажу про курс подробнее. Вводная лекция произвела очень благоприятное впечатление. Приятно говорящий (а главное, не бородатый!) дядька, хорошо оформленные слайды (потом узнал, что над картинками трудился отдельный дизайнер). Лекции записаны из реальной аудитории, слышно реакцию студентов (в основном смех). Рассказали, что понимают под AI сегодня, что изменилось с 50-х годов, показали видео из машин Google, а также своего робота, который аккуратно складывает рубашки и футболки. Мда, в моем ВУЗе передача знаний про AI началась и закончилась рассказом о тесте Тьюринга.
Минус для меня — это невозможность скачать видео с субтитрами себе локально.
Лекции хорошо, а практика? Ага на первой неделе имеем (Optional) Math Self Diagnostic, (Optional) Python Refresher.
Приведу здесь пример вопроса из раздела Math:
> You are playing a solitaire game in which you are dealt three cards without replacement from a simplified deck of 10 cards (marked 1 through 10). You win if one of your cards is a 10 or if all of your cards are odd.
>
> How many winning hands are there if different orders are different hands?
>
> What is your chance of winning?
>
>
Собственно высшее техническое образование шепчет: «Где-то это уже было...» С помощью википедии математика вспомнилась. В python refresher было заглянул, но уверенность в своих силах, которая поселилась после Лутца и двух курсов, дала волю лени, и делать задачку я не стал, решив перейти к недели второй.
##### Поиск и деревья
С понятием графов и раскрытием поискового дерева был ознакомлен в ВУЗе. Поэтому ожидал, что будет скучновато. Но показанный преподавателем желтый старина Пэкмен удержал интерес. Depth First, Breadth First, Uniform Cost, Greedy, A\*(with heuristic) Search — все это последовательно объяснялось, а в качестве примера служил Пэкмен, весело бегающий по лабиринту за точками в соответствии с алгоритмом поиска. И ни строчки кода в лекциях. Мне понравилось.
В тот же день с лекциями была осилена домашняя работа — графы и общие вопросы про жуков в лабиринте
А вот дальнейшая вкладка project 1 повергла в ступор. Скачайте [архив](https://www.edx.org/static/content-berkeley-cs188x~2012_Fall/projects/search/search.e063a0e5e897.zip) (подробнее [тут](http://www-inst.eecs.berkeley.edu/~cs188/pacman/pacman.html), спасибо [Nbooo](https://megamozg.ru/users/nbooo/)), запустите под python 2.7 pacman.py — поиграйте (можно запустить также с ключем -h для help). А теперь пишите свои функции в модуле search.py, ваш пэкмен должен найти еду в углу лабиринта. Вот так это выглядит.
Как же так, ведь как это написать нас не учили. Но раз уж взялся. Работа отставлена в сторону. В первый день было написано несколько кривых реализаций Depth First Search, пэкмен регулярно начал добираться до еды. Но они безжалостно удалялись, оказалось количество вскрытых поиском ветвей и оптимальность пути жестко контролируется. Тестируются ваши функции и методы автоматически, после загрузки исходных текстов на сервер. В очередной раз стерев страницу кода, бросил свой меч и взялся за орало. Листочки бумаги покрывались деревьями, рисунками пэкмена и лабиринта. Коллеги-электронщики считали своим долгом ухмыльнуться, проходя мимо. В итоге реализация была найдена. Кто хочет поучится — стоит помучаться самостоятельно. От тех кто на ты с питоном и алгоритмами, буду рад услышать замечания по делу.
**Код**Думаю тут все понятно, util.Stack() и utilQueue() — фактически списки, обернутые в классы для удобства учащихся, с методами push и pop, FIFO и LIFO соответственно:
```
def depthFirstSearch(problem):
"""
Search the deepest nodes in the search tree first
Your search algorithm needs to return a list of actions that reaches
the goal. Make sure to implement a graph search algorithm
To get started, you might want to try some of these simple commands to
understand the search problem that is being passed in:
print "Start:", problem.getStartState()
>>> Start: (4, 3)
print "Is the start a goal?", problem.isGoalState(problem.getStartState())
>>> Is the start a goal? False
print "Start's successors:", problem.getSuccessors(problem.getStartState())
>>> Start's successors: [((4, 4), 'North', 1), ((4, 2), 'South', 1), ((5, 3), 'East', 1), ((3, 3), 'West', 1)]
"""
def fromXYtoXY(coord1, coord2):
'''
tuple(int,int), tuple(int,int) -> str
Takes near coord1 coord2 tuples, returns string way, or error
sample for tinyMaze:
>>>fromXYtoXY((5,5),(4,5))
>>>'West'
>>>fromXYtoXY((1,3),(2,3))
>>>'East'
'''
if coord1[0]==coord2[0]:
if coord1[1]-coord2[1]==1:
return 'South'
else:
return 'North'
elif coord1[1]==coord2[1]:
if coord1[0]-coord2[0]==1:
return 'West'
else:
return 'East'
else:
return ('Path not found from %s to %s' % (coord1, coord2))
Fringe = util.Stack()
currState=problem.getStartState()
Fringe.push([currState])
while True:
currState=Fringe.pop()
if problem.isGoalState(currState[-1]):
listWays=[]
fromState=currState[0] # формируем выходной список с путями
for state in currState[1:]: # ex: ['South', 'West']
listWays.append(fromXYtoXY(fromState,state))
fromState=state
return listWays
break
for State, Way, Price in problem.getSuccessors(currState[-1]):
if not State in currState:
nextPath=currState[:]
nextPath.append(State)
Fringe.push(nextPath)
```
Реализация Breadth First Search, по-моему, вышла уже немного красивее.
**Код**
```
def breadthFirstSearch(problem):
"""
Search the shallowest nodes in the search tree first.
"""
fringe=util.Queue()
visitedNodes=[]
fringe.push([problem.getStartState(),[]]) # сохраним стартовые координаты + нулевой путь
while not fringe.isEmpty(): #пока в очереди есть чтото
currNode = fringe.pop() #берем последний
if currNode[0] not in visitedNodes: #если не было посещено
visitedNodes.append(currNode[0]) #добавим
for State, Way, Price in problem.getSuccessors(currNode[0]):
path=currNode[1][:] #сделаем путь для дочерней ветки
path.append(Way)
if problem.isGoalState(State):
return path
else:
fringe.push([State, path])
```
Потом были уже относительно легко реализованы Uniform Cost Search и A\* Search (с Евклидовым расстоянием до еды в качестве heuristic-функции)
**Код**
```
def uniformCostSearch(problem):
"Search the node of least total cost first. "
fringe=util.PriorityQueue()
visitedNodes=[]
fringe.push([problem.getStartState(),[],0],0)
while not fringe.isEmpty():
currNode = fringe.pop()
if problem.isGoalState(currNode[0]):
return currNode[1]
if currNode[0] not in visitedNodes: #если не было посещено
visitedNodes.append(currNode[0]) #добавим
for State, Way, Price in problem.getSuccessors(currNode[0]):
path=currNode[1][:] #сделаем путь к дочерней ветке
totalCost=currNode[2]+Price
path.append(Way)
fringe.push([State, path, totalCost],totalCost)
def aStarSearch(problem, heuristic=nullHeuristic):
"Search the node that has the lowest combined cost and heuristic first."
"*** YOUR CODE HERE ***"
fringe=util.PriorityQueue()
visitedNodes=[]
fringe.push([problem.getStartState(),[],0],0)
while not fringe.isEmpty():
currNode = fringe.pop()
if problem.isGoalState(currNode[0]):
print 'Success!!', currNode[1]
return currNode[1]
if currNode[0] not in visitedNodes: #если не было посещено
visitedNodes.append(currNode[0]) #добавим
for State, Way, Price in problem.getSuccessors(currNode[0]):
#print 'succ', State, Way, Price
path=currNode[1][:] #сделаем путь к дочерней ветке
totalCost=currNode[2]+Price
path.append(Way)
fringe.push([State, path, totalCost],totalCost+heuristic(State,problem))
```
Во второй части project 1 учащимся предлагалось видоизменить проблемы поиска в модуле searchAgents.py, адаптировав методы дочерних классов. Если раньше был один Пэкмен и одна еда, то теперь один Пэкмен и еда в 4-х углах, пройтись по которым нужно по оптимальному пути. А также придумать heuristic-функцию для A\* Search, который призван сократить затраты на раскрытие ветвей дерева поиска (система оценки следующая: inconsistent heuristics will get no credit. 1 point for any non-trivial consistent heuristic. 1 point for expanding fewer than 1600 nodes. 1 point for expanding fewer than 1200 nodes.).
Закончился project 1 решением проблемы оптимального поедания множества точек в лабиринте.
В итоге почти 3 рабочих дня я потратил на решение этих задач, хорошо на работе было некоторое затишье. Поломать голову было интересно и, надеюсь, что полезно в перспективе.
Закончить хочу шутливыми словами преподавателя в одной из лекций:
Anything you want to do, NP-hard. Sorry, this is an AI class. Everything is hard.
Надеюсь, обзор немного помог кому-то. Курс (или просто порешать задачи) советую всем начинающим знакомится с python, а сам с нетерпением жду project 2.
upd. [часть 2](http://habrahabr.ru/post/159433/) | https://habr.com/ru/post/154959/ | null | ru | null |
# В мире антропоморфных животных: PVS-Studio проверил Overgrowth
Недавно в сети появилась новость о том, что был открыт исходный код игры Overgrowth. Мы не смогли пройти мимо и проверили его качество с помощью PVS-Studio. Давайте же вместе посмотрим, где больше интересного экшена: в игре или в её исходном коде!
### О проекте
Overgrowth – вышедшая 14 лет назад игра от компании Wolfire Games. Это экшен с видом от 3-го лица, действие которого происходит в мрачном средневековом мире животных с повадками людей. В игре очень интересная система управления и довольно продвинутый ИИ. В ходе прохождения игроку даётся полная свобода передвижений и организации своих действий. Присутствует многопользовательский режим.
Overgrowth построен на движке Phoenix. Он содержит улучшенную модель движения. Бег, прыжки, перекаты, повороты происходят плавно, а также все позы и анимация изменяются в зависимости от окружения, настроения и даже индивидуальности каждого персонажа. На окружающую среду игры действует погода, даже деревья будут расти быстрее под солнечными лучами.
Анонс Overgrowth произошёл 17 сентября 2008 года, окончательная версия игры вышла 16 октября 2017 года.
Так как с момента публикации исходного кода в проект непрерывно коммитят, я зафиксировал его версией: [f2a67f7](https://github.com/WolfireGames/overgrowth/tree/f2a67f79e3205a45bd90ed5021276b9e6aa86132).
Итак, давайте разберём самые интересные предупреждения, которые удалось найти при помощи проверки проекта PVS-Studio.
### Результаты проверки
#### Предупреждения N1, N2
Начнём, пожалуй, с функции, в которой PVS-Studio выдал два предупреждения на соседние строки кода.
* [V611](https://pvs-studio.com/ru/docs/warnings/v611/) [CERT-MEM51-CPP] The memory was allocated using 'new T[]' operator but was released using the 'delete' operator. Consider inspecting this code. It's probably better to use 'delete [] heightfieldData;'. PhysicsServerCommandProcessor.cpp 4741
* [V773](https://pvs-studio.com/ru/docs/warnings/v773/) [CERT-MEM31-C, CERT-MEM51-CPP] The function was exited without releasing the 'worldImporter' pointer. A memory leak is possible. PhysicsServerCommandProcessor.cpp 4742
```
bool PhysicsServerCommandProcessor::processCreateCollisionShapeCommand(....)
{
btMultiBodyWorldImporter* worldImporter = new btMultiBodyWorldImporter(....);
....
const unsigned char* heightfieldData = 0;
....
heightfieldData = new unsigned char[width * height * sizeof(btScalar)];
....
delete heightfieldData;
return ....;
}
```
Похоже, что программист, который писал данную функцию, не очень знаком с принципами работы с динамической памятью в С++.
Начнём с предупреждения [V773](https://pvs-studio.com/ru/docs/warnings/v773/), как наиболее тривиального. Память под указатель *worldImporter* была выделена при помощи оператора *new* и по выходу из функции не была освобождена. Это плохая практика, которая приводит к утечке ресурсов. Поправить данный фрагмент кода можно было бы, позвав оператор *delete* по завершению работы с этим указателем.
Перейдём к предупреждению [V611](https://pvs-studio.com/ru/docs/warnings/v611/) и буферу *heightfieldData*. Тут разработчик очистил динамически выделенную память, однако сделал это неправильно. Вместо того, чтоб позвать оператор *delete[]* для освобождения аллоцированной ранее памяти при помощи оператора *new[]*, он позвал простой *delete*. Согласно стандарту, такой код явно приведёт к неопределённому поведению, вот [ссылка](https://timsong-cpp.github.io/cppwp/n4861/expr.delete#2) на соответствующий пункт.
Поправленный фрагмент кода:
```
bool PhysicsServerCommandProcessor::processCreateCollisionShapeCommand(....)
{
btMultiBodyWorldImporter* worldImporter = new btMultiBodyWorldImporter(....);
....
const unsigned char* heightfieldData = 0;
....
heightfieldData = new unsigned char[width * height * sizeof(btScalar)];
....
delete worldImporter;
delete[] heightfieldData;
return ....;
}
```
Также проблем с ручной очисткой памяти можно избежать, написав код посовременнее. Например, использовав *std::unique\_ptr* для автоматического освобождения памяти. Такой код будет короче и надёжнее. Он защитит от ошибок неосвобождённой памяти при досрочном выходе из функции:
```
bool PhysicsServerCommandProcessor::processCreateCollisionShapeCommand(....)
{
auto worldImporter = std::make_unique ();
....
std::unique\_ptr heightfieldData;
....
heightfieldData = std::make\_unique\_for\_overwrite
(width \* height \* sizeof(btScalar));
....
return ....;
}
```
#### Предупреждение N3
[V772](https://pvs-studio.com/ru/docs/warnings/v772/) [CERT-MSC15-C] Calling a 'delete' operator for a void pointer will cause undefined behavior. OVR\_CAPI\_Util.cpp 380
```
typedef struct ovrHapticsClip_
{
const void* Samples;
....
} ovrHapticsClip;
....
OVR_PUBLIC_FUNCTION(void) ovr_ReleaseHapticsClip(ovrHapticsClip* hapticsClip)
{
if (hapticsClip != NULL && hapticsClip->Samples != NULL)
{
delete[] hapticsClip->Samples;
....
}
}
```
Применение операторов *delete* и *delete[]* для указателя на void ведёт к [неопределённому поведению](https://timsong-cpp.github.io/cppwp/n4861/expr.delete#footnote-73). Чтобы избежать ошибки, нужно явно привести указатель к его фактическому типу при очистке памяти.
Чтобы понять, как глубока проблема, я провёл небольшое исследование. Поле *Samples* инициализируется только в одном месте и типом *uint8\_t\**. Вот пруф:
```
.... ovr_GenHapticsFromAudioData(ovrHapticsClip* outHapticsClip, ....)
{
....
uint8_t* hapticsSamples = new uint8_t[hapticsSampleCount];
....
outHapticsClip->Samples = hapticsSamples;
....
}
```
Это говорит об архитектурной ошибке при проектировании класса. Возможно, раньше оно инициализировалось разными типами и это убрали вследствие рефакторинга, а изменить тип поля *Samples* с *void\** на *uint8\_t\** забыли.
Разработчикам в любом случае стоит обратить внимание на этот участок кода и поправить его, он странный и ведёт к UB.
#### Предупреждение N4
[V595](https://pvs-studio.com/ru/docs/warnings/v595/) [CERT-EXP12-C] The 'ctx' pointer was utilized before it was verified against nullptr. Check lines: 130, 131. ascontext.cpp 130
```
class ASContext
{
public:
asIScriptContext *ctx;
}
ASContext::ASContext(....)
{
ctx = ....;
ctx->SetUserData(this, 0);
if( ctx == 0 )
{
FatalError("Error","Failed to create the context.");
return;
}
....
}
```
В данном фрагменте кода указатель *ctx* сначала разыменовывается, а потом проверяется на *0*. Это выглядит довольно подозрительно. Если программист опасается, что *ctx* может быть равен *nullptr*, то, возможно, его стоит разыменовывать уже после проверки:
```
ASContext::ASContext(....)
{
ctx = ....;
if( !ctx )
{
FatalError("Error","Failed to create the context.");
return;
}
ctx->SetUserData(this, 0);
....
}
```
#### Предупреждение N5
[V547](https://pvs-studio.com/ru/docs/warnings/v547/) Expression 'connect\_id\_ == - 1' is always true. placeholderobject.cpp 342
```
class PlaceholderObject
{
private:
int connect_id_;
....
};
ObjectSanityState PlaceholderObject::GetSanity()
{
....
if( .... && connect_id_ == -1)
{
if( connect_id_ == -1)
{
....
}
}
....
}
```
В данном фрагменте кода анализатор заметил избыточную проверку *connect\_id\_ == -1*. Она уже была выполнена в условии верхнего уровня, и переменная *connect\_id\_* с этого момента не менялась.
Возможно, в условии, на которое указывает анализатор, должна была проверяться какая-нибудь другая переменная или данная проверка просто избыточна и код можно упростить:
```
ObjectSanityState PlaceholderObject::GetSanity()
{
....
if( .... && connect_id_ == -1 )
{
....
}
....
}
```
#### Предупреждение N6
[V791](https://pvs-studio.com/ru/docs/warnings/v791/) The initial value of the index in the nested loop equals 'i'. Perhaps, 'i + 1' should be used instead. navmeshhintobject.cpp 65
```
NavmeshHintObject::NavmeshHintObject()
{
....
for( int i = 0; i < 8; i++ )
{
for( int k = i; k < 8; k++ )
{
if( i != k )
{
if(
corners[i][0] == corners[k][0] ||
corners[i][1] == corners[k][1] ||
corners[i][2] == corners[k][2]
)
{
cross_marking.push_back(corners[i]);
cross_marking.push_back(corners[k]);
}
}
}
}
....
}
```
Здесь анализатор выявил неоптимальный цикл. Используется паттерн кода с выполнением некоторых операций для пар элементов массива. При этом анализатор понял, что нет смысла выполнять операцию для пары, состоящей из одного и того же элемента *i == j*. Данный фрагмент кода можно упростить:
```
NavmeshHintObject::NavmeshHintObject()
{
....
for( int i = 0; i < 8; i++ )
{
for( int k = i + 1; k < 8; k++ )
{
if(
corners[i][0] == corners[k][0] ||
corners[i][1] == corners[k][1] ||
corners[i][2] == corners[k][2]
)
{
cross_marking.push_back(corners[i]);
cross_marking.push_back(corners[k]);
}
}
}
....
}
```
#### Предупреждение N7
[V561](https://pvs-studio.com/ru/docs/warnings/v561/) [CERT-DCL01-C] It's probably better to assign value to 'other\_radius\_sq' variable than to declare it anew. Previous declaration: scenegraph.cpp, line 2006. scenegraph.cpp 2010
```
bool SceneGraph::AddDynamicDecal(....)
{
....
float other_radius_sq = ....;
if(....)
{
....
float other_radius_sq = ....;
}
....
}
```
Анализатор обнаружил подозрительный фрагмент кода. Здесь происходит переопределение переменной *other\_radius\_sq*. Зачастую появление сущностей с одинаковыми именами — следствие неудачной копипасты.
#### Предупреждения N8, N9
* [V547](https://pvs-studio.com/ru/docs/warnings/v547/) Expression 'imageBits == 8' is always false. texture\_data.cpp 305
* [V547](https://pvs-studio.com/ru/docs/warnings/v547/) Expression 'imageBits == 24' is always false. texture\_data.cpp 313
```
void TextureData::GetUncompressedData(unsigned char* data)
{
int imageBits = 32;
....
if (imageBits == 8)
{
....
}
else if (imageBits == 24)
{
....
}
....
}
```
Значение переменной *imageBits* не меняется между инициализацией и проверками. Скорее всего, это не ошибка, просто анализатор выявил странный недописанный или избыточный фрагмент кода. Разработчикам стоит обратить на него внимание!
#### Предупреждения N10, N11
[V769](https://pvs-studio.com/ru/docs/warnings/v769/) [CERT-EXP08-C] The 'idx\_buffer\_offset' pointer in the 'idx\_buffer\_offset += pcmd->ElemCount' expression equals nullptr. The resulting value is senseless and it should not be used. imgui\_impl\_sdl\_gl3.cpp 138
```
void ImGui_ImplSdlGL3_RenderDrawLists(ImDrawData* draw_data)
{
const ImDrawIdx* idx_buffer_offset = 0;
....
idx_buffer_offset += pcmd->ElemCount;
....
}
```
Анализатор обнаружил подозрительную операцию сложения, применяемую к нулевому указателю. Указатель далее не используется. Да и нельзя его использовать. В общем, это какой-то бессмысленный код.
Ещё одно похожее срабатывание:
[V769](https://pvs-studio.com/ru/docs/warnings/v769/) [CERT-EXP08-C] The 'cp' pointer in the 'cp ++' expression equals nullptr. The resulting value is senseless and it should not be used. crn\_file\_utils.cpp 547
```
int file_utils::wildcmp(...., const char* pString)
{
const char* cp = NULL;
....
pString = cp++;
....
}
```
Данный фрагмент также похож на последствия рефакторинга или криво реализованный алгоритм. Что имели в виду разработчики — остаётся только гадать...
#### Предупреждение N12
[V523](https://pvs-studio.com/ru/docs/warnings/v523/) The 'then' statement is equivalent to the 'else' statement. skeleton.cpp 152
```
void Skeleton::SetGravity( bool enable )
{
if(enable)
{
for(unsigned i=0; iSetGravity(true);
//physics\_bones[i].bullet\_object->SetDamping(0.0f);
}
}
else
{
for(unsigned i=0; iSetGravity(true);
//physics\_bones[i].bullet\_object->SetDamping(1.0f);
}
}
}
```
В продолжение обзора странного кода. Анализатор обнаружил *if* с одинаковыми *then* и *else*. Скорее всего, разработчик просто не дописал второй фрагмент кода. Об этом можно судить по разным закомментированным фрагментам в ветках кода.
#### Предупреждение N13
[V728](https://pvs-studio.com/ru/docs/warnings/v728/) An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. as\_compiler.cpp 4317
```
void asCCompiler::CompileIfStatement(....)
{
bool constructorCall1 = ....;
bool constructorCall2 = ....;
....
if ( (constructorCall1 && !constructorCall2)
||(constructorCall2 && !constructorCall1) )
{
....
}
}
```
Давайте рассмотрим фрагмент кода, который сам по себе не является ошибкой. На самом деле, мне просто очень нравится эта диагностика. Она проста и изящна.
PVS-Studio обнаружил паттерн в проверяемом условии, который можно упростить — и сделать код существенно читабельнее. Программист пытается понять, что произошёл вызов одного или другого конструктора. Операция, которую он применяет очень похожа на *XOR*. Однако в C++ нет *исключающего "ИЛИ"* для типа *bool*, и порой это выливается в гораздо более громоздкий код. Переписать его можно, например, таким образом:
```
void asCCompiler::CompileIfStatement(....)
{
bool constructorCall1 = ....;
bool constructorCall2 = ....;
....
if (constructorCall1 != constructorCall2)
{
....
}
}
```
#### Предупреждения N14, N15, N16
[V610](https://pvs-studio.com/ru/docs/warnings/v610/) [CERT-INT34-C] Undefined behavior. Check the shift operator '<<'. The right operand ('i' = [0..63]) is greater than or equal to the length in bits of the promoted left operand. bitarray.cpp 77
```
class Bitarray
{
private:
uint64_t *arr;
....
};
void Bitarray::SetBit( size_t index )
{
size_t p = index/64;
size_t i = index%64;
arr[p] |= (1UL << i);
}
```
PVS-Studio обнаружил опасный код со сдвигом влево беззнакового числа. Согласно стандарту, это неопределённое поведение, если правый операнд больше или равен разрядности левого операнда. Литерал *1UL* под *MSVC* представлен *32* битами, правый операнд же лежит в диапазоне от *0* до *63*.
Так как код рассчитан в том числе и для сборки под Windows, разработчикам стоит обратить внимание на него. Вот ещё несколько предупреждений с такой же проблемой:
* [V610](https://pvs-studio.com/ru/docs/warnings/v610/) [CERT-INT34-C] Undefined behavior. Check the shift operator '<<'. The right operand ('i' = [0..63]) is greater than or equal to the length in bits of the promoted left operand. bitarray.cpp 85
* [V610](https://pvs-studio.com/ru/docs/warnings/v610/) [CERT-INT34-C] Undefined behavior. Check the shift operator '<<'. The right operand ('i' = [0..63]) is greater than or equal to the length in bits of the promoted left operand. bitarray.cpp 93
#### Предупреждение N17
[V751](https://pvs-studio.com/ru/docs/warnings/v751/) [CERT-MSC13-C] Parameter 'rayTo' is not used inside function body. btSoftBody.cpp 2148
```
btScalar btSoftBody::RayFromToCaster::rayFromToTriangle(
const btVector3& rayFrom,
const btVector3& rayTo,
const btVector3& rayNormalizedDirection,
const btVector3& a,
const btVector3& b,
const btVector3& c,
btScalar maxt)
{
static const btScalar ceps = -SIMD_EPSILON * 10;
static const btScalar teps = SIMD_EPSILON * 10;
const btVector3 n = btCross(b - a, c - a);
const btScalar d = btDot(a, n);
const btScalar den = btDot(rayNormalizedDirection, n);
if (!btFuzzyZero(den))
{
const btScalar num = btDot(rayFrom, n) - d;
const btScalar t = -num / den;
if ((t > teps) && (t < maxt))
{
const btVector3 hit = rayFrom + rayNormalizedDirection * t;
if ((btDot(n, btCross(a - hit, b - hit)) > ceps) &&
(btDot(n, btCross(b - hit, c - hit)) > ceps) &&
(btDot(n, btCross(c - hit, a - hit)) > ceps))
{
return (t);
}
}
}
return (-1);
}
```
Здесь анализатор говорит о формальном параметре *rayTo*, который не используется в теле функции. При этом параметр *rayFrom* используется несколько раз, что может свидетельствовать об ошибке или не очень удачном рефакторинге кода.
### Заключение
В результате проверки анализатор нашёл в проекте ошибки разного рода: традиционные опечатки, довольно много неправильной работы с памятью, логические ошибки. Мы надеемся, что благодаря данной статье, разработчики Overgrowth смогут поправить некоторые недочёты, а может быть, захотят самостоятельно перепроверить свою кодовую базу PVS-Studio. Это безусловно поможет замечательной игре и дальше радовать своих фанатов в уже новых, менее подверженных багам сборках :)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку: [In the world of anthropomorphic animals: PVS-Studio checks Overgrowth](https://pvs-studio.com/en/blog/posts/cpp/0957/) | https://habr.com/ru/post/673090/ | null | ru | null |
# JIT-компилятор Python в 300 строк
Может ли студент второго курса написать [JIT](https://en.wikipedia.org/wiki/Just-in-time_compilation)-компилятор Питона, конкурирующий по производительности с промышленным решением? С учётом того, что он это сделает за две недели за зачёт по программированию.
Как оказалось, может, но с нюансами.
Предисловие
-----------
Обучаясь в РТУ МИРЭА, на специальности "Программная инженерия" я попал на семестровый курс программирования на Питоне. Питон я знал до этого, поэтому не хотелось много с ним возиться. Благо творчество студентов поощряется, иногда даже "автоматами". Собственно, стимулируемый этим "автоматом" и тягой к написанию системных модулей я написал JIT-компилятор, который назвал *MetaStruct*.
С кодом проекта можно ознакомиться в [репозитории](https://github.com/PenzaStreetGames/MetaStruct.git).
[Предыдущий мой опыт](https://github.com/PenzaStreetGames/Yo.git) в написании низкоуровневых программ оказался нежизнеспособным и весьма поучительным. Но об этом сегодня речь не пойдёт.
Стандартная реализация Python - CPython - достаточно медленная. В сравнении с C++ называют замедление в [20-30 раз](https://towardsdatascience.com/how-fast-is-c-compared-to-python-978f18f474c7). Но целое сообщество программистов на Питоне готовы заплатить эту цену ради удобства синтаксиса, быстроты написания, изящности и выразительности кода.
На этой почве появляются разнообразные способы оптимизации выполнения программ на Питоне. Такие диалекты как [Cython](https://cython.org/) и [RPython](https://rpython.readthedocs.io/en/latest/) пытаются решить проблему "разгона" Питона за счёт статической типизации и компиляции модулей.
В области JIT-компиляции промышленным решением является проект [Numba](https://numba.pydata.org/), спонсируемый такими технологическими гигантами как Intel, AMD и NVIDIA. Именно с этим пакетом мне предложили и посоревноваться, написав миниатюрный JIT-компилятор программ на Питоне.
В этой статье я хочу рассказать, с какими трудностями я, как программист достаточно прикладной, столкнулся при написании такой довольно низкоуровневой вещи, как миниатюрный JIT-компилятор.
Принцип работы
--------------
Архитектура разработанного JIT-компилятораНа схеме выше показано, какие этапы проходит функция на Питоне, становясь скомпилированным модулем на С++:
1. Функция, которую мы хотим оптимизировать, помечается аннотацией `@jit`, примерно так:
```
@jit
def sum(x: int, y: int) -> int:
res: int = x + y
return res
```
2. Аннотация, получая объект функции, с помощью `inspect.getsource(func_object)` получает текст функции в виде строки.
3. С помощью функции `ast.parse(func_py_text)` текст функции превращается в абстрактное синтаксическое дерево (AST) языка Питон
4. Моя программа проходится по дереву через метод `visit()`, наследуясь от `ast.NodeVisitor`, и получает на выходе текст программы на C++, который записывается в файл. Для примера выше, он будет примерно таким:
```
extern "C" int sum(int x, int y) {
int res = (x + y);
return res;
}
```
5. Через `subprocess.run()` происходит вызов компилятора [g++](https://gcc.gnu.org/releases.html), который выдаёт динамически подключаемую библиотеку (в зависимости от платформы файлом `.dll` или `.so`)
```
g++ -O2 -c source.cpp -o object.o
g++ -shared object.o -o lib.dll
```
6. При помощи вызова `ctypes.LibraryLoader(CDLL).LoadLibrary(dll_filename)` Динамическая библиотека подключается к среде выполнения и даёт доступ к скомпилированному варианту исходной функции.
7. Конечный пользователь, добавивший над функцией аннотацию `@jit`, пользуется совершенно другим вариантом своего кода, ничего не подозревая.
Процесс достаточно трудоёмкий для функции сложения из примера, но при частых вызовах и большом количестве вычислений внутри функции время компиляции окупается.
Если бы это был не Питон, а какой-нибудь предметно-ориентированный язык, то пришлось бы писать парсер и обход получившегося абстрактного дерева, и решение не было бы уже таким коротким. Но в моём случае, инфраструктура Питона и его гибкость сыграли мне на руку.
Впечатляющие результаты
-----------------------
Наверное, стоит от технической части переходить к части визуализации и маркетинга.
Созданный алгоритм JIT-компиляции был протестирован на нескольких простых алгоритмических задачах:
* Сумма двух чисел.
* Хеш-функция для целых чисел.
* Вычисление экспоненты через ряд Тейлора.
* Числа Фибоначчи.
С расчётами и графиками можно подробнее ознакомиться в
[Jupyter-блокноте](https://github.com/PenzaStreetGames/MetaStruct/blob/main/performance.ipynb)
Для оценки времени выполнения использованы функции `timeit()` и `repeat()` модуля `timeit`. Для отрисовки графиков - модуль `matplotlib`
В примерах будут сравниваться четыре реализации функций:
* Просто функции питона.
* Оптимизированные аннотацией `@jit`.
* Оптимизированные аннотацией `@numba.jit`.
* Запущенные на интерпретаторе PyPy
*Примечание: Я добавил к рассмотрению PyPy по просьбе одного из читателей. И этот метод оптимизации Питона действительно иногда является очень эффективным, что подтверждают графики ниже. Но при его использовании есть много нюансов.*
*Первый, это совершенно другая среда запуска, количество поддерживаемых библиотек которой значительно меньше, встроить в большой проект с уймой сторонних модулей просто так не получится.*
*Второй, версии PyPy выходят позже версий самого Питона. На момент написания статьи в PyPy не было конструкции match/case, поэтому пришлось использовать более простую и длинную реализацию обхода дерева.*
*Поэтому я призываю не сильно разочаровываться в jit-компиляторах, которые в отличие от PyPy не зависят от конкретной версии Питона и списка библиотек вашего проекта.*
### Сумма двух чисел
Скорость многократного выполнения, функция суммы
```
def py_sum(x: int, y: int) -> int:
res: int = x + y
return res
```
На задаче сложения двух целых чисел никакой оптимизации не видно, даже наоборот. Накладные расходы на вызов функции из dll-файла и обработка результата занимает много времени по сравнению с самими расчётами. Numba обставила моего "питомца" в 3 раза на этом примере.
Модуль PyPy отработал в 30 раз (0.003 секунды против 0.1 секунды) быстрее, чем CPython.
### Хеш-функция для целых чисел
Скорость многократного выполнения, хеш-функцияОбычно, для чисел из небольшого диапазона в качестве хеша используют их самих. Однако на просторах Интернета я нашёл такую [хеш-функцию](https://qastack.ru/programming/664014/what-integer-hash-function-are-good-that-accepts-an-integer-hash-key):
```
def py_hash(x: int) -> int:
x = ((x >> 16) ^ x) * 0x45d9f3b
x = ((x >> 16) ^ x) * 0x45d9f3b
x = (x >> 16) ^ x
return x
```
Автором сообщения утверждается, что значение параметра `0x45d9f3b` позволяет достичь наибольшей "случайности" бит внутри числа. По крайней мере, для хеш-функций такого вида.
Numba оказалась хорошо оптимизированной под битовые операции. Не совсем понятно, откуда она взялась. Оставим этот вопрос открытым, но мне кажется, спонсорство главных производителей процессоров и видеокарт не прошло даром. Мой же вариант оказался слегка быстрее простого Питона, и то не всегда.
PyPy и тут обставил оптимизаторы, выполнив прогоны за 0.002 секунды, то есть в 100 раз быстрее, чем Numba.
### Вычисление экспоненты через ряд Тейлора
Скорость многократного выполнения, экспонентаСтранное большое время для маленького x, выяснилось, обосновано тем, что Numba делает какие-то отложенные шаги компиляции при первом запуске. На общей её производительности это почти никак не сказывается (на втором графике с методами оптимизации аномалия исчезла, потому что был произведён повторный прогон).
Питон явно показал себя неважно, поэтому посмотрим на двух оптимизаторов и PyPy отдельно.
Скорость многократного выполнения, экспонента, методы оптимизации крупным планом
```
def py_exp(x: float) -> float:
res: float = 0
threshold: float = 1e-30
delta: float = 1
elements: int = 0
while delta > threshold:
elements = elements + 1
delta = delta * x / elements
while elements >= 0:
res += delta
delta = delta * elements / x
elements -= 1
return res
```
Кому интересен матан, экспонента считается по формуле соответствующего ряда Тейлора:
Алгоритм прекращается, когда разница между дельтами двух итераций становится меньше порога, либо превращается в машинный ноль. Суммирование происходит от меньших членов к большим для уменьшения потерь точности.
Наконец-то моё творение начало соперничать с Numba. На больших объёмах вычислений однозначного лидера нет. PyPy уже потерял преимущество в два порядка и выполняется с такой же скоростью, как и jit-оптимизаторы.
### Числа Фибоначчи
Скорость выполнения, числа Фибоначчи
```
def fib(n: int) -> int:
if n < 2:
return 1
return fib(n - 1) + fib(n - 2)
```
Несмотря на то, что аннотация позволяет компилировать функции по одной, в ней всё ещё можно использовать рекурсию.
На рекурсии Питон вообще перестал за себя отвечать. Что там с оптимизаторами?
Скорость выполнения, числа Фибоначчи, методы оптимизации крупным планомВнезапно, реализованная в проекте компиляция начала работать в 4 раза быстрее, чем Numba и в 8 раз быстрее PyPy. Получается, что с задачами разветвлённой рекурсии мой JIT-компилятор неплохо справляется.
Это одно из самых интересных мест всего исследования, которое можно было бы продолжить.
Мысли сходятся
--------------
На самом деле, такой подход к оптимизации не нов в мире программирования. Чем-то похожим занимался Владимир Макаров, оптимизируя Ruby до уровня языка передачи регистров [RTL](https://en.wikipedia.org/wiki/Register_transfer_language) в своём проекте MJIT.
Существуют даже оптимизации сделанные поверх решения Макарова, о которых можно почитать [здесь](https://k0kubun.medium.com/the-method-jit-compiler-for-ruby-2-6-388ee0989c13).
В частности, в исследованиях отмечается, что выбор компилятора, будь то GCC или LLVM, существенно не сказывается на производительности. В моём решении использован g++ из-за большей портируемости скомпилированного кода.
Для ускорения вычислений в проекте Ruby используются также предкомплированные заголовки. Однако, для студенческой работы такой уровень оптимизации не требуется.
Непредвиденные трудности
------------------------
Конечно же, всё заработало не с первого раза. Вероятно, даже не с десятого. Поэтому хотелось бы привести здесь небольшую "работу над ошибками"
### Типы данных
Питон медленный во многом из-за динамической типизации, так как довольно много времени уходит на определение типа переменной перед её использованием. Также, идеология "всё есть объект" раздувает примитивные типы данных до размера остальных объектов и классов. Чтобы ускорить вычисления, нужно использовать именно примитивы, а не объекты.
Проблема в том, что из кода на Питоне не всегда очевидно, какого типа будет переменная. Продвинутые оптимизаторы умеют определять тип переменной "на лету" из контекста. Я решил не усложнять жизнь ~~, а усложнить код,~~ и использовать аннотации типов.
Про использование аннотаций типов есть хорошие статьи в [официальной документации](https://docs.python.org/3/library/typing.html) или на [Хабре](https://habr.com/ru/company/lamoda/blog/432656/).
Пусть нужно скомпилировать ту самую функцию сложения:
```
def sum(x, y):
res = x + y
return res
```
Какой-нибудь компилируемый язык, C++ например, за такую программу спасибо не скажет. Добавим аннотации:
```
def sum(x: int, y: int) -> int:
res: int = x + y
return res
```
В этом примере явного объявления типов требуют три вещи:
1. Аргументов функции.
2. Возвращаемое из функции значение.
3. Локальные переменные.
В базовой реализации будет только три типа данных:
| Тип данных Python | Тип данных C++ |
| --- | --- |
| bool | bool |
| int | int |
| float | double |
Использование более сложных типов данных выходит за задачу миниатюрности компилятора. Но стоит отметить, что строки, коллекции и объекты Питона могут быть поддержаны с использованием [Python C API](https://docs.python.org/3/c-api/index.html)
### Кодирование имён функций
С++ видоизменяет названия функций согласно их сигнатуре и аргументам. Например, функцию `int f(int x)` компилятор может преобразовать в `_Z1fi`. Подробнее о соглашении именования функции при компиляции можно узнать, например, [здесь](https://en.wikipedia.org/wiki/Name_mangling)
После переименования к функциям уже нельзя обратиться по первоначальному названию. Конечно, можно было бы написать свой алгоритм, который делает те же преобразования, что и компилятор. Но на самом деле, существует более простое решение, к которому мне пришлось в итоге прийти.
При добавлении к объявлению функции префикса `extend "C"` имена не будут кодироваться:
```
extern "C" int sum(int x, int y) {
int res = (x + y);
return res;
}
```
Так происходит, потому что мы явно указываем, что имена функций должны кодироваться по соглашению языка C, то есть, никак.
### Запуск DLL
Как программисту, плохо знакомому с чем-то ниже C++, мне было трудно понять, как подключить собранную dll-библиотеку к Питону. Изначально была идея использовать `rundll32.exe` для запуска. Почитав [Википедию](https://ru.wikipedia.org/wiki/Rundll32.exe) и [ещё одно обсуждение](https://stackoverflow.com/questions/3207365/how-to-use-rundll32-to-execute-dll-function), я немного разочаровался в прикладной применимости и портируемости этого решения.
Потом я нашёл статью с говорящим названием: [What’s the guidance on when to use rundll32? Easy: Don’t use it](https://devblogs.microsoft.com/oldnewthing/20130104-00/?p=5643)
Только после этого я был направлен на путь истинный, а точнее, на использование модуля `ctypes`. В этот момент мои скомпилированные функции впервые начали возвращать мне значения прямо в Питоне.
### Вызов функции из DLL
Всё шло гладко, пока я оперировал целыми числами. При попытке считать дробные... возвращались целые очень странного формата.
```
# просто питон
print(exp(0.1))
# >>> 1.1051709180756475
# моё чудо
print(jit_exp(0.1))
# >>> -1285947181
```
Как оказалось, по умолчанию, все функции, импортируемые из dll работают с аргументами как с int и возвращают тоже int. Тут до меня дошло, что возвращать просто строку программы на C++ из транслятора недостаточно. Из функций необходимо ещё получить сигнатуру, чтобы потом применить нужные типы из модуля `ctypes`. Метод посещения объявления функции начал выглядеть вот так:
```
def visit_FunctionDef(self, node: FunctionDef) -> Tuple[str, dict]:
ret_type = self.visit(node.returns)
name = node.name
args, args_signature = [], []
for arg in node.args.args:
arg, arg_type = self.visit(arg)
args.append(f"{arg_type} {arg}")
args_signature.append(ctype_convert(arg_type))
args = ", ".join(args)
res = f"extern \"C\" {ret_type} {name}({args}) {{\n"
res += self.dump_body(node.body) + "}"
signature = {
"argtypes": args_signature,
"restype": ctype_convert(ret_type)
}
return res, signature
```
Появился метод встраивания этих типов в сигнатуру dll:
```
def jit(func: Callable) -> Callable:
exec_module, signatures = compile_dll(func)
name = func.__name__
jit_func = exec_module[name]
jit_func.argtypes = signatures[name]["argtypes"]
jit_func.restype = signatures[name]["restype"]
return jit_func
```
Для того чтобы функции вызывались так же хорошо, как с целыми числами, достаточно было поменять у функций внутри загруженного dll атрибуты `argtypes` и `restype`. Сами типы для подстановки были взяты из модуля ctypes:
```
def ctype_convert(type_str: str):
match type_str:
case "int":
return ctypes.c_int
case "double":
return ctypes.c_double
case "bool":
return ctypes.c_bool
case _:
raise Exception(f"unsupported type str {type_str}")
```
После всех этих ~~накручиваний костылей~~ махинаций ответ экспоненты начал совпадать с Питоном.
Подробнее про использование функций, загруженных из DLL, можно почитать в этой [статье](https://habr.com/ru/post/499152/)
Немного магии
-------------
Хороший код не пишется сразу. Например, в моём проекте основные блоки пришлось переписать два раза. В крупных проектах борьба с тех. долгом вообще может уходить в бесконечность, но я пока что, к сожалению или к счастью, с этим не сталкивался.
Я хотел показать на примере функции синтаксического разбора бинарной операции `ast.BinOp` как можно по-разному писать код, который будет в разной степени сложно поддерживать.
### Словарь с типами
Это самая первая реализация:
```
def dump_bin_op(module: ast.BinOp) -> str:
res = ""
left = dump_expr(module.left)
right = dump_expr(module.right)
op = module.op
bin_op_signs = {
ast.Add: "+",
ast.Sub: "-",
ast.Div: "/",
ast.Mult: "*",
# и ещё 6-8 бинарных операций
}
op_sign = bin_op_signs[type(op)]
return f"({left} {op_sign} {right})"
```
По сравнению с блоком `if-elif-elif-elif-...-else` такой код кажется проще. Но тут происходит явное обращение к типу через `type()`, что не очень хорошо.
### Match/case
Тут мне посоветовали начать уже использовать плюшки версии Питона 3.10 на полную катушку, а именно, применить сравнение по шаблону и оператор `match/case`
```
def dump_bin_op(module: ast.BinOp) -> str:
match module:
case ast.BinOp(op=ast.Add()):
op_sign = "+"
case ast.BinOp(op=ast.Sub()):
op_sign = "-"
case ast.BinOp(op=ast.Div()):
op_sign = "/"
case ast.BinOp(op=ast.Mult()):
op_sign = "*"
# и ещё 6-8 бинарных операций
case _:
raise Exception(f"unsupported bin op type {op_type}")
left = dump_expr(module.left)
right = dump_expr(module.right)
return f"({left} {op_sign} {right})"
```
Код стал чуточку короче и выразительнее. Шаблоны после слова `case` можно всячески усложнять, выбирая всё более специфичные случаи. Какой-нибудь `switch/case` в таких языках программирования как C++ или Java такого себе не может позволить. Подробнее про возможности оператора `match/case` можно узнать [тут](https://docs-python.ru/tutorial/tsikly-upravlenie-vetvleniem-python/konstruktsija-match-case/)
Вот ещё маленький пример, решающий проблему занижения регистра для констант `True` и `False`:
```
def visit_Constant(self, node: Constant) -> str:
match node:
case Constant(value=True):
return "true"
case Constant(value=False):
return "false"
case _:
return str(node.value)
```
Выглядит покрасивее, чем `if node.value == True:`. Но тут уже на вкус и цвет.
### ast.NodeVisitor
Вот я и пришёл к тому, что давно написали за меня, но я об этом никогда не слышал, поэтому ещё не применил.
Как ни странно, модуль, описывающий абстрактное дерево в виде структуры, предоставляет также и методы для его обхода. Этот метод называется `ast.NodeVisitor.visit()`
Как следует из названия, NodeVisitor реализует шаблон проектирования [Посетитель](https://refactoring.guru/ru/design-patterns/visitor), позволяющий создавать новую внешнюю функциональность с минимальным изменением уже написанного кода.
Для написания своего посетителя необходимо объявить класс-наследник класса `ast.NodeVisitor`:
```
class DumpVisitor(ast.NodeVisitor):
...
def visit_BinOp(self, node: ast.BinOp) -> str:
return f"({self.visit(node.left)} {self.visit(node.op)} {self.visit(node.right)})"
def visit_Add(self, node: ast.Add) -> str:
return "+"
def visit_Sub(self, node: ast.Sub) -> str:
return "-"
def visit_Div(self, node: ast.Div) -> str:
return "/"
def visit_Mult(self, node: ast.Mult) -> str:
return "*"
# ещё 6-8 методов обхода бинарных операций
... # и не только
```
Код остальных методов посетителя можно изучить в [репозитории](https://github.com/PenzaStreetGames/MetaStruct/blob/main/tree_to_code/dump_visitor.py).
Код стал более модульным, названия и сигнатуры методов уже придуманы за нас, выбор нужного метода происходит без нашего участия. Вот на этом варианте я и решил остановиться.
Во время написания кода на Питоне у меня возникает чувство ощущения красоты, краткости и мощи собственного кода. В этом есть какая-то магия.
Подсчёт строк
-------------
Дабы не потерять доверие читателя, я провёл подсчёт строк кода транслятора:
| Код | Объём |
| --- | --- |
| Аннотация и процесс компиляции | 36 |
| Транслятор на NodeVisitor | 221 |
| **Итого** | **257** |
Остальные файлы, как оказалось, к процессу исполнения напрямую не причастны. Я даже не стал исключать того большого числа пустых строк, которого требует PEP8. Получается, что даже немного наврал читателю насчёт числа строк. Пусть он меня простит.
Думаю, такой небольшой проект можно было бы легко поддерживать, если бы в этом была бы необходимость.
Итог
----
Хочу сказать спасибо [Петру Николаевичу Советову](https://habr.com/ru/users/true-grue/) за наставничество при написании этого проекта и этой статьи. Как оказывается, писать статьи труднее, чем писать код в ящик.
Проекту в плане функциональности есть куда расти. Поддержка строк, коллекций, объектов, классов. Правда с учётом полученного зачёта, предлагаю энтузиастам, взяв моё решение за основу, добиться большей производительности и функциональности.
Предел у этого совершенства всё равно есть. На поддержке библиотек такие решения оптимизации обычно отказываются работать либо поддерживают самые популярные и базовые, такие как Numpy или PIL.
И всё же, если очень захотеть, можно заставить Питон работать быстрее, уничтожая один из извечных аргументов программистов на C++ и Java против использования Python. | https://habr.com/ru/post/674206/ | null | ru | null |
# Notepad++: проверка кода пять лет спустя
В этом году статическому анализатору PVS-Studio исполнилось 10 лет. Правда, стоит уточнить, что 10 лет назад он назывался Viva64. И есть ещё одна интересная дата: прошло 5 лет с момента предыдущей проверки кода проекта Notepad++. С тех пор PVS-Studio был очень сильно доработан: добавлено около 190 новых диагностик, усовершенствованы старые. Впрочем, ожидать огромного количества ошибок в Notepad++ не стоит. Это небольшой проект, состоящий всего из 123 файлов с исходным кодом. Тем не менее, в коде найдены ошибки, которые будет полезно исправить.
Введение
--------
[Notepad++](https://notepad-plus-plus.org/) — свободный текстовый редактор с открытым исходным кодом для Windows, с подсветкой синтаксиса большого количества языков программирования и разметки. Базируется на компоненте Scintilla, написан на C++ с использованием STL, а также Windows API и распространяется под лицензией GNU General Public License.
На мой взгляд, Notepad++ отличный текстовой редактор. Я сам его использую для всего, кроме написания кода. Для анализа исходников я воспользовался статическим анализатором [PVS-Studio](https://www.viva64.com/ru/pvs-studio/) 6.15. Проект Notepad++ уже проверялся в [2010](https://www.viva64.com/ru/b/0083/) и [2012](https://www.viva64.com/ru/b/0131/) годах. Сейчас нашлось 84 предупреждения уровня High, 124 предупреждения уровня Medium и 548 предупреждений уровня Low. Уровни предупреждений указывают на достоверность найденных ошибок. Так, из 84-х наиболее достоверных предупреждений (High), 81, на мой взгляд, указывают на настоящие дефекты в коде — их стоит сразу исправить, не вникая глубоко в логику программы, т.к. проблемы очевидны.
Примечание. Кроме обработки результатов статического анализатора, будет полезно улучшить код, определившись: использовать для отступов пробелы или табы. Абсолютно весь код выглядит примерно так:
*Рисунок 1 — Разные отступы в коде.*
Давайте рассмотрим некоторые ошибки, которые показались мне наиболее интересными.
Проблемы наследования
---------------------
[V599](http://www.viva64.com/ru/w/V599/) The virtual destructor is not present, although the 'FunctionParser' class contains virtual functions. functionparser.cpp 39
```
class FunctionParser
{
friend class FunctionParsersManager;
public:
FunctionParser(....): ....{};
virtual void parse(....) = 0;
void funcParse(....);
bool isInZones(....);
protected:
generic_string _id;
generic_string _displayName;
generic_string _commentExpr;
generic_string _functionExpr;
std::vector \_functionNameExprArray;
std::vector \_classNameExprArray;
void getCommentZones(....);
void getInvertZones(....);
generic\_string parseSubLevel(....);
};
std::vector \_parsers;
FunctionParsersManager::~FunctionParsersManager()
{
for (size\_t i = 0, len = \_parsers.size(); i < len; ++i)
{
delete \_parsers[i]; // <=
}
if (\_pXmlFuncListDoc)
delete \_pXmlFuncListDoc;
}
```
Анализатором была найдена серьёзная ошибка, приводящая к неполному разрушению объектов. У базового класса *FunctionParser* присутствует виртуальная функция *parse()*, но отсутствует виртуальный деструктор. В иерархии наследования от этого класса присутствуют такие классы, как *FunctionZoneParser*, *FunctionUnitParser* и *FunctionMixParser*:
```
class FunctionZoneParser : public FunctionParser
{
public:
FunctionZoneParser(....): FunctionParser(....) {};
void parse(....);
protected:
void classParse(....);
private:
generic_string _rangeExpr;
generic_string _openSymbole;
generic_string _closeSymbole;
size_t getBodyClosePos(....);
};
class FunctionUnitParser : public FunctionParser
{
public:
FunctionUnitParser(....): FunctionParser(....) {}
void parse(....);
};
class FunctionMixParser : public FunctionZoneParser
{
public:
FunctionMixParser(....): FunctionZoneParser(....), ....{};
~FunctionMixParser()
{
delete _funcUnitPaser;
}
void parse(....);
private:
FunctionUnitParser* _funcUnitPaser = nullptr;
};
```
Для наглядности я составил схему наследования для этих классов:
*Рисунок 2 — Схема наследования от класса FunctionParser*
Таким образом, созданные объекты будут разрушаться не полностью. Это приведёт к неопределённому поведению программы. Нельзя сказать как будет вести себя программа после того, как в ней возникнет UB, но на практике в данном случае, как минимум, произойдёт утечка памяти, так как код «delete \_funcUnitPaser» не будет выполнен.
Рассмотрим следующую ошибку.
[V762](http://www.viva64.com/ru/w/V762/) It is possible a virtual function was overridden incorrectly. See first argument of function 'redraw' in derived class 'SplitterContainer' and base class 'Window'. splittercontainer.h 61
```
class Window
{
....
virtual void display(bool toShow = true) const
{
::ShowWindow(_hSelf, toShow ? SW_SHOW : SW_HIDE);
}
virtual void redraw(bool forceUpdate = false) const
{
::InvalidateRect(_hSelf, nullptr, TRUE);
if (forceUpdate)
::UpdateWindow(_hSelf);
}
....
}
class SplitterContainer : public Window
{
....
virtual void display(bool toShow = true) const; // <= good
virtual void redraw() const; // <= error
....
}
```
В коде Notepad++ найдено несколько проблем с перегрузкой функций. В классе *SplitterContainer*, унаследованного от класса Window, метод *display()* перегружен правильно, а при перегрузке метода *redraw()* допустили ошибку.
Ещё несколько неправильных мест:
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'UserDefineDialog' and base class 'StaticDialog'. userdefinedialog.h 332
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'FindReplaceDlg' and base class 'StaticDialog'. findreplacedlg.h 245
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'GoToLineDlg' and base class 'StaticDialog'. gotolinedlg.h 45
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'FindCharsInRangeDlg' and base class 'StaticDialog'. findcharsinrange.h 52
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'ColumnEditorDlg' and base class 'StaticDialog'. columneditor.h 45
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'WordStyleDlg' and base class 'StaticDialog'. wordstyledlg.h 77
* V762 It is possible a virtual function was overridden incorrectly. See first argument of function 'redraw' in derived class 'WordStyleDlg' and base class 'Window'. wordstyledlg.h 99
* V762 It is possible a virtual function was overridden incorrectly. See third argument of function 'create' in derived class 'PluginsAdminDlg' and base class 'StaticDialog'. pluginsadmin.h 107
Утечки памяти
-------------
[V773](http://www.viva64.com/ru/w/V773/) The function was exited without releasing the 'pXmlDocProject' pointer. A memory leak is possible. projectpanel.cpp 326
```
bool ProjectPanel::openWorkSpace(const TCHAR *projectFileName)
{
TiXmlDocument *pXmlDocProject = new TiXmlDocument(....);
bool loadOkay = pXmlDocProject->LoadFile();
if (!loadOkay)
return false; // <=
TiXmlNode *root = pXmlDocProject->FirstChild(TEXT("Note...."));
if (!root)
return false; // <=
TiXmlNode *childNode = root->FirstChildElement(TEXT("Pr...."));
if (!childNode)
return false; // <=
if (!::PathFileExists(projectFileName))
return false; // <=
....
delete pXmlDocProject; // <= free pointer
return loadOkay;
}
```
Интересным примером утечки памяти является вот такая функция. Под указатель *pXmlDocProject* выделяется динамическая память, но освобождается она только при выполнении функции до конца. Что, скорее всего, является недоработкой, приводящей к утечкам памяти.
[V773](http://www.viva64.com/ru/w/V773/) Visibility scope of the 'pTextFind' pointer was exited without releasing the memory. A memory leak is possible. findreplacedlg.cpp 1577
```
bool FindReplaceDlg::processReplace(....)
{
....
TCHAR *pTextFind = new TCHAR[stringSizeFind + 1];
TCHAR *pTextReplace = new TCHAR[stringSizeReplace + 1];
lstrcpy(pTextFind, txt2find);
lstrcpy(pTextReplace, txt2replace);
....
}
```
Функция *processReplace()* вызывается при каждой замене некой подстроки в документе. В коде выделяется память под два буфера: *pTextFind* и *pTextReplace*. В один буфер копируется искомая строка, а в другой — строка для замены. Тут присутствует несколько ошибок, следствием которых является утечка памяти:
1. Буфер pTextFind не очищается и вообще не используется в функции. Для замены используется исходный буфер *txt2find*.
2. Буфер pTextReplace в дальнейшем используется, но память тоже не освобождается.
Вывод: каждая операция автозамены приводит к утечке нескольких байт. Чем больше искомая строка и чем больше совпадений, тем больше течёт память.
Ошибки с указателями
--------------------
[V595](http://www.viva64.com/ru/w/V595/) The 'pScint' pointer was utilized before it was verified against nullptr. Check lines: 347, 353. scintillaeditview.cpp 347
```
LRESULT CALLBACK ScintillaEditView::scintillaStatic_Proc(....)
{
ScintillaEditView *pScint = (ScintillaEditView *)(....);
if (Message == WM_MOUSEWHEEL || Message == WM_MOUSEHWHEEL)
{
....
if (isSynpnatic || makeTouchPadCompetible)
return (pScint->scintillaNew_Proc(....); // <=
....
}
if (pScint)
return (pScint->scintillaNew_Proc(....));
else
return ::DefWindowProc(hwnd, Message, wParam, lParam);
}
```
В одном месте пропустили проверку указателя *pScint* на валидность.
[V713](http://www.viva64.com/ru/w/V713/) The pointer \_langList[i] was utilized in the logical expression before it was verified against nullptr in the same logical expression. parameters.h 1286
```
Lang * getLangFromID(LangType langID) const
{
for (int i = 0 ; i < _nbLang ; ++i)
{
if ((_langList[i]->_langID == langID) || (!_langList[i]))
return _langList[i];
}
return nullptr;
}
```
Автор кода допустил ошибку при записи условного выражения. Он сначала обращается к полю *\_langID*, используя указатель *\_langList[i]*, а потом сравнивает этот указатель с нулём.
Скорее всего, правильный код должен быть таким:
```
Lang * getLangFromID(LangType langID) const
{
for (int i = 0 ; i < _nbLang ; ++i)
{
if ( _langList[i] && _langList[i]->_langID == langID )
return _langList[i];
}
return nullptr;
}
```
Разные ошибки
-------------
[V501](http://www.viva64.com/ru/w/V501/) There are identical sub-expressions to the left and to the right of the '!=' operator: subject != subject verifysignedfile.cpp 250
```
bool VerifySignedLibrary(...., const wstring& cert_subject, ....)
{
wstring subject;
....
if ( status && !cert_subject.empty() && subject != subject)
{
status = false;
OutputDebugString(
TEXT("VerifyLibrary: Invalid certificate subject\n"));
}
....
}
```
Помнится, в Notepad++ была найдена уязвимость, позволяющая подменять компоненты редактора на модифицированные. В код были добавлены проверки целостности. Я точно не знаю, этот код был написан для закрытия уязвимости или нет, но по названию функции можно судить, что служит она для важной проверки.
На фоне этого проверка:
```
subject != subject
```
выглядит крайне подозрительно, скорее всего, правильно должно быть так:
```
if ( status && !cert_subject.empty() && cert_subject != subject)
{
....
}
```
[V560](http://www.viva64.com/ru/w/V560/) A part of conditional expression is always true: 0xff. babygrid.cpp 711
```
TCHAR GetASCII(WPARAM wParam, LPARAM lParam)
{
int returnvalue;
TCHAR mbuffer[100];
int result;
BYTE keys[256];
WORD dwReturnedValue;
GetKeyboardState(keys);
result = ToAscii(static_cast(wParam),
(lParam >> 16) && 0xff, keys, &dwReturnedValue, 0); // <=
returnvalue = (TCHAR) dwReturnedValue;
if(returnvalue < 0){returnvalue = 0;}
wsprintf(mbuffer, TEXT("return value = %d"), returnvalue);
if(result!=1){returnvalue = 0;}
return (TCHAR)returnvalue;
}
```
Всегда истинные или всегда ложные условные выражения выглядят очень подозрительно. Константа *0xff* всегда истинна. Возможно, допустили опечатку в операторе и параметр функции *ToAscii()* должен был быть таким:
```
(lParam >> 16) & 0xff
```
[V746](http://www.viva64.com/ru/w/V746/) Type slicing. An exception should be caught by reference rather than by value. filedialog.cpp 183
```
TCHAR* FileDialog::doOpenSingleFileDlg()
{
....
try {
fn = ::GetOpenFileName(&_ofn)?_fileName:NULL;
if (params->getNppGUI()._openSaveDir == dir_last)
{
::GetCurrentDirectory(MAX_PATH, dir);
params->setWorkingDir(dir);
}
} catch(std::exception e) { // <=
::MessageBoxA(NULL, e.what(), "Exception", MB_OK);
} catch(...) {
::MessageBox(NULL, TEXT("....!!!"), TEXT(""), MB_OK);
}
::SetCurrentDirectory(dir);
return (fn);
}
```
Перехватывать исключения лучше по ссылке. Проблема такого кода заключается в том, что будет создан новый объект, что приведёт к потере информации об исключении при перехвате. Всё, что хранилось в унаследованных от *Exception* классах, будет недоступно.
[V519](http://www.viva64.com/ru/w/V519/) The 'lpcs' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 3116, 3117. babygrid.cpp 3117
```
LRESULT CALLBACK GridProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
....
case WM_CREATE:
lpcs = &cs
lpcs = (LPCREATESTRUCT)lParam;
....
}
```
Сразу перетёрли старое значение новым. Похоже на ошибку. Если сейчас всё работает правильно, то следует оставить только вторую строчку с присваиванием, а первую удалить.
[V601](http://www.viva64.com/ru/w/V601/) The 'false' value becomes a class object. treeview.cpp 121
```
typedef std::basic_string generic\_string;
generic\_string TreeView::getItemDisplayName(....) const
{
if (not Item2Set)
return false; // <=
TCHAR textBuffer[MAX\_PATH];
TVITEM tvItem;
tvItem.hItem = Item2Set;
tvItem.mask = TVIF\_TEXT;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX\_PATH;
SendMessage(...., reinterpret\_cast(&tvItem));
return tvItem.pszText;
}
```
Возвращаемым значением функции является строка, но вместо пустой строки кто-то решил сделать «return false».
Чистка кода
-----------
Делать рефакторинг ради рефакторинга не стоит, в любом проекте есть много других полезных задач. Но избавляться от бесполезного кода однозначно нужно.
[V668](http://www.viva64.com/ru/w/V668/) There is no sense in testing the 'source' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. notepad\_plus.cpp 1149
```
void Notepad_plus::wsTabConvert(spaceTab whichWay)
{
....
char * source = new char[docLength];
if (source == NULL)
return;
....
}
```
Вот зачем здесь эта проверка? Согласно современному стандарту C++, оператор *new* бросает исключение при нехватке памяти, а не возвращает *nullptr*.
Эта функция зовётся при замене всех символов табуляции на пробелы во всём документе. Взяв большой текстовый документ, я убедился, что нехватка памяти в этом месте действительно приводит к краху программы.
Если корректировать проверку, то при нехватке памяти будет происходить отмена операции замены символов, и редактором можно пользоваться дальше. Все такие места следует исправить, и их так много, что пришлось вынести список в [отдельный файл](http://cppfiles.com/NotepadPP3_V668.txt).
[V713](http://www.viva64.com/ru/w/V713/) The pointer commentLineSymbol was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 3928
```
bool Notepad_plus::doBlockComment(comment_mode currCommentMode)
{
....
if ((!commentLineSymbol) || // <=
(!commentLineSymbol[0]) ||
(commentLineSymbol == NULL)) // <= WTF?
{ .... }
....
}
```
Таких странных и бесполезных проверок найдено десять штук:
* V713 The pointer commentLineSymbol was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 3928
* V713 The pointer commentStart was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 3931
* V713 The pointer commentEnd was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 3931
* V713 The pointer commentStart was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 4228
* V713 The pointer commentEnd was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 4228
* V713 The pointer commentLineSymbol was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 4229
* V713 The pointer commentStart was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 6554
* V713 The pointer commentEnd was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 6554
* V713 The pointer commentLineSymbol was utilized in the logical expression before it was verified against nullptr in the same logical expression. notepad\_plus.cpp 6555
[V601](http://www.viva64.com/ru/w/V601/) The 'true' value is implicitly cast to the integer type. pluginsadmin.cpp 603
```
INT_PTR CALLBACK PluginsAdminDlg::run_dlgProc(UINT message, ....)
{
switch (message)
{
case WM_INITDIALOG :
{
return TRUE;
}
....
case IDC_PLUGINADM_RESEARCH_NEXT:
searchInPlugins(true);
return true;
case IDC_PLUGINADM_INSTALL:
installPlugins();
return true;
....
}
....
}
```
Функция *run\_dlgProc()* и так возвращает значение далеко не логического типа, так ещё в коде возвращают то *true/false*, то *TRUE/FALSE*. Хотел написать, что в функции хотя бы отступы одного типа, но нет: из 90 строк функции в одной строке все равно присутствует смесь из табуляций и пробелов. В остальных строках используются символы табуляции. Да, это всё не критично, но код выглядит для меня, как стороннего наблюдателя, неаккуратным.
[V704](http://www.viva64.com/ru/w/V704/) '!this' expression in conditional statements should be avoided — this expression is always false on newer compilers, because 'this' pointer can never be NULL. notepad\_plus.cpp 4980
```
void Notepad_plus::notifyBufferChanged(Buffer * buffer, int mask)
{
// To avoid to crash while MS-DOS style is set as default
// language,
// Checking the validity of current instance is necessary.
if (!this) return;
....
}
```
К бесполезному коду я бы ещё отнёс такие проверки. Как видно из комментария, раньше проблема разыменования нулевого *this* была. Согласно же современному стандарту языка C++, такая проверка является лишней.
Список всех таких мест:
* V704 'this && type == DOCUMENT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxmla.h 505
* V704 'this && type == ELEMENT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxmla.h 506
* V704 'this && type == COMMENT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxmla.h 507
* V704 'this && type == UNKNOWN' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxmla.h 508
* V704 'this && type == TEXT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxmla.h 509
* V704 'this && type == DECLARATION' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxmla.h 510
* V704 'this && type == DOCUMENT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxml.h 505
* V704 'this && type == ELEMENT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxml.h 506
* V704 'this && type == COMMENT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxml.h 507
* V704 'this && type == UNKNOWN' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxml.h 508
* V704 'this && type == TEXT' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxml.h 509
* V704 'this && type == DECLARATION' expression should be avoided: 'this' pointer can never be NULL on newer compilers. tinyxml.h 510
* V704 'this' expression in conditional statements should be avoided — this expression is always true on newer compilers, because 'this' pointer can never be NULL. nppbigswitch.cpp 119
Заключение
----------
Были найдены и другие ошибки, которые не вошли в статью. При желании авторы Notepad++ могут самостоятельно проверить проект и внимательно изучить предупреждения. Мы готовы предоставить им для этого временную лицензию.
Конечно, обычному пользователю описанные проблемы не видны. Модули оперативной памяти сейчас больших объёмов и дешёвые :). Тем не менее, развитие проекта продолжается, а качество кода, как и удобство его поддержки, можно значительно улучшить, исправив найденные ошибки и удалив пласты устаревшего кода.
По моим расчётам, на 1000 строк кода анализатор PVS-Studio выявлял 2 настоящие ошибки. Конечно, это не все ошибки. Думаю, на самом деле их будет где-то 5-10 на 1000 строк кода, что соответствует небольшой плотности ошибок. Размер проекта Notepad++ составляет 95 KLoc, а значит типичная плотность ошибок для проектов этого размера: 0-40 ошибок на 1000 строк кода. Впрочем, источник этих чисел стар, и я считаю, что, в среднем, качество кода сейчас стало выше.
Ещё раз хочу поблагодарить авторов Notepad++ за их работу над крайне полезным инструментом и желаю им всевозможных успехов.
[](http://www.viva64.com/en/b/0511/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [Checking Notepad++: five years later](http://www.viva64.com/en/b/0511/)
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/330394/ | null | ru | null |
# Реализация счетчика наработки на микроконтроллере 1986BE92QI
Здравствуйте. Хочу поделиться алгоритмом и программной реализацией счетчика времени наработки изделия на микроконтроллере 1986BE92QI на языке Си.
Очень часто появляется необходимость отсчитывать время, отработанное некоторым устройством. Для ведения счетчика наработки необходимо периодически с определенным интервалом времени, например каждую минуту, обновлять значение, хранящееся в ячейке энергонезависимой памяти EEPROM. К сожалению, ресурс циклов записи и стирания этих ячеек памяти обычно мал и составляет около 10.000 циклов (по оценке производителя). Значит, если стирать и перезаписывать значение в одну и туже ячейку памяти с интервалом в 1 минуту, то ресурс ячейки будет израсходован примерно за неделю. Для увеличения этого времени можно использовать не одну ячейку, а все ячейки некоторой, свободной страницы памяти, например последней. Это даст нам 1024 \* 10.000 запас циклов записи и стирания, что эквивалентно, примерно 19 годам при ежеминутной перезаписи значений счетчика. Или использовать даже две страницы, в зависимости от требований. В микроконтроллере 1986BE92QI доступны 32 страницы энергонезависимой памяти для записи программы и 1 страница информационной энергонезависимой памяти по 4 кбайт. Каждая страница поделена на 4 сектора (SECTOR\_A, SECTOR\_B, SECTOR\_C, SECTOR\_D). Разбитие страницы на сектора дает возможность стирать данные страницы не целиком, а поблочно по 256 четырех байтных слова в четыре этапа.
Итак, для ведения счетчика наработки можно использовать следующий алгоритм. Значение счетчика записывается в первую ячейку первого сектора (SECTOR\_A). Через минуту происходит инкремент счетчика и его значение записывается во вторую ячейку первого сектора и так до конца сектора. Затем осуществляется переход на следующий сектор (SECTOR\_B), но перед записью значений происходит стирание этого сектора и выполняется запись значения в первую ячейку сектора B, затем во вторую ячейку и так далее до конца страницы. Заполнение всей страницы данными происходит за 1024 минуты. Когда вся страница заполнена осуществляется переход на первый сектор SECTOR\_A, он предварительно очищается, т.к. сохранившиеся там данные нам уже не нужны, ведь самые актуальные значения находятся в секторе D. И продолжается запись данных уже в первый сектор.
Каждое записываемое в ячейку памяти значение состоит из четырех байт. В первых трех байтах находится само значение счетчика минут. В четвертом байте 8 битная, посчитанная для этих трех байт контрольная сумма CRC8. Эта контрольная сумма позволяет определять испорченность записанных данных. Ниже приведена структура записываемого в память значения счетчика с тремя байтами данных uint8\_t val[3] и байтом контрольной суммы uint8\_t crc.
```
typedef struct
{
union
{
struct
{
uint8_t val[3];
uint8_t crc;
};
uint32_t value;
};
} counter_value_t;
```
Если записанная контрольная сумма не будет совпадать с подсчитанной контрольной суммой, то это означает, что данные в данной ячейке испорчены и их использовать нельзя и необходимо взять предыдущее значение минут. Потеря одной-двух минут не будет критичной, если надо подсчитать несколько лет наработки.
Испортить записываемое значение также возможно, если произойдет отключение питания микроконтроллера во время записи в ячейку EEPROM. Наличие контрольной суммы также позволяет определять испорченные значения при записи.
При первом запуске микроконтроллер проходится последовательно по каждой ячейке памяти страницы, считывает значение счетчика и ищется максимальное не испорченное значение. С адреса следующего за этим значением продолжится ведение записи счетчика в память.
В листинге ниже представлен код на языке Си для реализации описанного алгоритма.
```
#include
#include
#include
#include
#include
#include
#include
// Стартовый адрес страницы для записи.
#define PAGE 0x0801F000
#define SECTORA (PAGE)
#define SECTORB (PAGE + 0x04)
#define SECTORC (PAGE + 0x08)
#define SECTORD (PAGE + 0x0C)
// Кол-во секторов в странице
#define SECTORS 4
// Кол-во 32 битных слов в странице
#define WORDS 256
// EEPROM Bank Selector
#define BANK\_SELECT EEPROM\_Main\_Bank\_Select
#define EEPROM\_REG\_ACCESS\_KEY ((uint32\_t)0x8AAA5551)
#define DELAY\_LOOP\_CYCLES (8UL)
#define GET\_US\_LOOPS(N) ((uint32\_t)((float)(N) \* FLASH\_PROG\_FREQ\_MHZ / DELAY\_LOOP\_CYCLES))
#pragma anon\_unions
typedef struct
{
union
{
struct
{
uint8\_t val[3]; // Значение счетчика
uint8\_t crc; // Контрольная сумма
};
uint32\_t value;
};
} counter\_value\_t;
typedef enum {
RC\_OK = 0,
RC\_EMPTY = 1,
RC\_CRCERR = 2
}rc\_mem\_t;
const uint32\_t sectors[4]={
SECTORA,
SECTORB,
SECTORC,
SECTORD
};
uint32\_t last\_eeprom\_word = 0; // Последнее прочитанное значение
uint32\_t eeprom\_word = 0; // Текущее прочитанное значение
uint32\_t sector = 0; // Текущий сектор
uint32\_t position = 0; // Текущая позиция в секторе
/\*\*----------------------------------------------------------------------------
\* @brief Program delay.
\* @param loops: Number of the loops.
\* @retval None.
\*/
\_\_RAMFUNC static void ProgramDelay(uint32\_t loops)
{
volatile uint32\_t i = loops;
for (; i > 0; i--)
{
}
}
/\*\*-----------------------------------------------------------------------------
\* @brief Стирание одного сектора.
\* @param adress: начальный адрес сектора.
\* @param bankSelector: выбранный банк памяти.
\* @retval None.
\*/
\_\_RAMFUNC void EEPROM\_EraseSector(uint32\_t address, uint32\_t bankSelector)
{
uint32\_t Command;
assert\_param(IS\_EEPROM\_BANK\_SELECTOR(BankSelector));
MDR\_EEPROM->KEY = EEPROM\_REG\_ACCESS\_KEY;
Command = (MDR\_EEPROM->CMD & EEPROM\_CMD\_DELAY\_Msk) | EEPROM\_CMD\_CON;
Command |= (bankSelector == EEPROM\_Info\_Bank\_Select) ? EEPROM\_CMD\_IFREN : 0;
MDR\_EEPROM->CMD = Command;
MDR\_EEPROM->ADR = address; // Page Address
MDR\_EEPROM->DI = 0;
Command |= EEPROM\_CMD\_XE | EEPROM\_CMD\_ERASE;
MDR\_EEPROM->CMD = Command;
ProgramDelay(GET\_US\_LOOPS(5)); // Wait for 5 us
Command |= EEPROM\_CMD\_NVSTR;
MDR\_EEPROM->CMD = Command;
ProgramDelay(GET\_US\_LOOPS(40000)); // Wait for 40 ms
Command &= ~EEPROM\_CMD\_ERASE;
MDR\_EEPROM->CMD = Command;
ProgramDelay(GET\_US\_LOOPS(5)); // Wait for 5 us
Command &= ~(EEPROM\_CMD\_XE | EEPROM\_CMD\_NVSTR);
MDR\_EEPROM->CMD = Command;
ProgramDelay(GET\_US\_LOOPS(1)); // Wait for 1 us
Command &= EEPROM\_CMD\_DELAY\_Msk;
MDR\_EEPROM->CMD = Command;
MDR\_EEPROM->KEY = 0;
}
/\*\*-----------------------------------------------------------------------------
\* @brief Получение значения.
\* @param adress: адресс ячеки для чтения.
\* @param bankSelector: выбранный банк памяти.
\* @param value: указатель на переменную для чтения значения из памяти.
\* @retval Результат операции.
\*/
rc\_mem\_t GetWord(uint32\_t address, uint32\_t bankSelector, uint32\_t \* value)
{
rc\_mem\_t ret = 0;
counter\_value\_t count;
uint8\_t crc = 0;
address -= address % 4;
\_\_disable\_irq();
count.value = EEPROM\_ReadWord (address, bankSelector);
\_\_enable\_irq();
crc = getCRC8byTable( count.val, 3);
if (count.value == 0xFFFFFFFF)
ret = RC\_EMPTY;
else if (count.crc != crc)
ret = RC\_CRCERR;
else
{
ret = RC\_OK;
\*value = count.value & 0x00FFFFFF;
}
return ret;
}
/\*\*-----------------------------------------------------------------------------
\* @brief Запись значения в память.
\* @param adress: адресс ячеки для записи.
\* @param bankSelector: выбранный банк памяти.
\* @param value: значение для записи в ячейку памяти.
\* @retval Результат операции.
\*/
void SetWord(uint32\_t address, uint32\_t bankSelector, uint32\_t value)
{
counter\_value\_t count;
address -= address%4;
memcpy( count.val, &value, 3);
count.crc = getCRC8byTable( count.val, 3);
\_\_disable\_irq();
EEPROM\_ProgramWord ( address, bankSelector, count.value);
\_\_enable\_irq();
}
/\*\*-----------------------------------------------------------------------------
\* @brief Ведение счетчика.
\* @param Нет.
\* @retval Нет.
\*/
void Moto()
{
static uint8\_t isFirst = 1;
uint32\_t i = 0;
rc\_mem\_t ret = 0;
// поиск текущего сектора
for (i = sector, last\_eeprom\_word = 0; i < 4; i++)
{
ret = GetWord(sectors[i], BANK\_SELECT, &eeprom\_word);
if ( ret == RC\_EMPTY || ret == RC\_CRCERR || eeprom\_word < last\_eeprom\_word)
break;
else
{
sector = i;
last\_eeprom\_word = eeprom\_word;
}
}
// поиск текущей позиции в секторе
for (i = 0; i < WORDS; i++)
{
ret = GetWord(sectors[sector] + i \* 16, BANK\_SELECT, &eeprom\_word);
if (ret == RC\_EMPTY)
break;
else if (ret != RC\_EMPTY)
last\_eeprom\_word = eeprom\_word + 1;
}
position = i;
if (isFirst)
{
isFirst = 0;
return;
}
// стираем следующий сектор, если начинать сначала
if (position == WORDS)
{
position = 0;
sector++;
if(sector == SECTORS )
sector = 0;
\_\_disable\_irq();
EEPROM\_EraseSector(sectors[sector], BANK\_SELECT);
\_\_enable\_irq();
}
// записываем значение + 1
SetWord(sectors[sector] + position \* 16, BANK\_SELECT, last\_eeprom\_word);
}
/\*\*----------------------------------------------------------------------------
\* @brief Получение значения.
\* @param Нет.
\* @retval Значение счетчика.
\*/
uint32\_t GetMoto()
{
return last\_eeprom\_word;
}
/\*\*-----------------------------------------------------------------------------
\* @brief Установка значения счетчика.
\* @param value: Значение счетчика.
\* @retval Нет.
\*/
void SetMoto(uint32\_t value)
{
\_\_disable\_irq();
EEPROM\_ErasePage (PAGE, BANK\_SELECT);
\_\_enable\_irq();
sector = 0;
position = 0;
last\_eeprom\_word = value;
SetWord(sectors[sector] + position \* 16, BANK\_SELECT, value);
}
```
Стоит обратить внимание, что при записи в EEPROM блокируются прерывания. Это может быть довольно критичным недостатком для приложений, в которых реализованы различные защиты на других прерываниях, например, прерываниях по компаратору.
Данная реализация счетчика содержит только минимальный необходимый набор проверок и контроля ошибок и не претендует на максимальную полноту охвата решаемой проблемы. Можно придумать и добавить дополнительные проверки, например, проверку сохраненного значения в памяти непосредственно после записи и т.д.
И, на всякий случай, реализация алгоритма вычисления контрольной суммы CRC8 табличным методом.
```
#include
const uint8\_t crc8tab[256] =
{
0x00, 0x31, 0x62, 0x53, 0xC4, 0xF5, 0xA6, 0x97,
0xB9, 0x88, 0xDB, 0xEA, 0x7D, 0x4C, 0x1F, 0x2E,
0x43, 0x72, 0x21, 0x10, 0x87, 0xB6, 0xE5, 0xD4,
0xFA, 0xCB, 0x98, 0xA9, 0x3E, 0x0F, 0x5C, 0x6D,
0x86, 0xB7, 0xE4, 0xD5, 0x42, 0x73, 0x20, 0x11,
0x3F, 0x0E, 0x5D, 0x6C, 0xFB, 0xCA, 0x99, 0xA8,
0xC5, 0xF4, 0xA7, 0x96, 0x01, 0x30, 0x63, 0x52,
0x7C, 0x4D, 0x1E, 0x2F, 0xB8, 0x89, 0xDA, 0xEB,
0x3D, 0x0C, 0x5F, 0x6E, 0xF9, 0xC8, 0x9B, 0xAA,
0x84, 0xB5, 0xE6, 0xD7, 0x40, 0x71, 0x22, 0x13,
0x7E, 0x4F, 0x1C, 0x2D, 0xBA, 0x8B, 0xD8, 0xE9,
0xC7, 0xF6, 0xA5, 0x94, 0x03, 0x32, 0x61, 0x50,
0xBB, 0x8A, 0xD9, 0xE8, 0x7F, 0x4E, 0x1D, 0x2C,
0x02, 0x33, 0x60, 0x51, 0xC6, 0xF7, 0xA4, 0x95,
0xF8, 0xC9, 0x9A, 0xAB, 0x3C, 0x0D, 0x5E, 0x6F,
0x41, 0x70, 0x23, 0x12, 0x85, 0xB4, 0xE7, 0xD6,
0x7A, 0x4B, 0x18, 0x29, 0xBE, 0x8F, 0xDC, 0xED,
0xC3, 0xF2, 0xA1, 0x90, 0x07, 0x36, 0x65, 0x54,
0x39, 0x08, 0x5B, 0x6A, 0xFD, 0xCC, 0x9F, 0xAE,
0x80, 0xB1, 0xE2, 0xD3, 0x44, 0x75, 0x26, 0x17,
0xFC, 0xCD, 0x9E, 0xAF, 0x38, 0x09, 0x5A, 0x6B,
0x45, 0x74, 0x27, 0x16, 0x81, 0xB0, 0xE3, 0xD2,
0xBF, 0x8E, 0xDD, 0xEC, 0x7B, 0x4A, 0x19, 0x28,
0x06, 0x37, 0x64, 0x55, 0xC2, 0xF3, 0xA0, 0x91,
0x47, 0x76, 0x25, 0x14, 0x83, 0xB2, 0xE1, 0xD0,
0xFE, 0xCF, 0x9C, 0xAD, 0x3A, 0x0B, 0x58, 0x69,
0x04, 0x35, 0x66, 0x57, 0xC0, 0xF1, 0xA2, 0x93,
0xBD, 0x8C, 0xDF, 0xEE, 0x79, 0x48, 0x1B, 0x2A,
0xC1, 0xF0, 0xA3, 0x92, 0x05, 0x34, 0x67, 0x56,
0x78, 0x49, 0x1A, 0x2B, 0xBC, 0x8D, 0xDE, 0xEF,
0x82, 0xB3, 0xE0, 0xD1, 0x46, 0x77, 0x24, 0x15,
0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC
};
//-----------------------------------------------------------------------------
//
// getCRC8byTable
//
// Calculation of the CRC-8
//
// Parametric model of CRC-8 algorithm:
// Name : CRC-8
// Poly : 0x31 x^8 + x^5 + x^4 + 1
// Init : 0xFF
// Revert: false
// XorOut: 0x00
// Check : 0xF7 ("123456789")
// MaxLen: 15 bytes(127 bits) - detection of single, dual,
// triple and all odd errors
//
uint8\_t getCRC8byTable( uint8\_t\* arr, uint16\_t len )
{
uint8\_t crc8 = 0xff;
unsigned int i;
for( i = 0; i< len; i++)
{
crc8 = crc8tab[ crc8 ^ arr[i] ];
}
return crc8;
}
//-----------------------------------------------------------------------------
//
// getCRC8
//
// calculation of the CRC directly
//
// Parametric model of CRC-8 algorithm:
// Name : CRC-8
// Poly : 0x31 x^8 + x^5 + x^4 + 1
// Init : 0xFF
// Revert: false
// XorOut: 0x00
// Check : 0xF7 ("123456789")
// MaxLen: 15 bytes(127 bits) - detection of single, dual,
// triple and all odd errors
//
uint8\_t getCRC8(uint8\_t \*pcBlock, uint16\_t len )
{
uint8\_t crc = 0xff;
unsigned int i;
while (len--)
{
crc ^= \*pcBlock++;
for (i = 0; i < 8; i++)
crc = crc & 0x80 ? (crc << 1) ^ 0x31 : crc << 1;
}
return crc;
}
``` | https://habr.com/ru/post/571172/ | null | ru | null |
# Как строить красивые графики на Python с Seaborn
> *Будущих студентов курса* [***«Python Developer. Professional»***](https://otus.pw/VvSD/) *и всех желающих приглашаем принять участие в открытом вебинаре на тему* [***«Фреймворкирование и метаклассы».***](https://otus.pw/r5LF/) *А сейчас делимся традиционным переводом полезного материала.*
>
>
---
Визуализация данных — это метод, который позволяет специалистам по анализу данных преобразовывать сырые данные в диаграммы и графики, которые несут ценную информацию. Диаграммы уменьшают сложность данных и делают более понятными для любого пользователя.
Есть множество инструментов для визуализации данных, таких как Tableau, Power BI, ChartBlocks и других, которые являются no-code инструментами. Они очень мощные, и у каждого своя аудитория. Однако для работы с сырыми данными, требующими обработки, а также в качестве песочницы, Python подойдет лучше всего.
Несмотря на то, что этот путь сложнее и требует умения программировать, Python позволит вам провести любые манипуляции, преобразования и визуализировать ваши данные. Он идеально подходит для специалистов по анализу данных.
Python — лучший инструмент для data science и этому много причин, но самая важная — это его экосистема библиотек. Для работы с данными в Python есть много замечательных библиотек, таких как `numpy`, `pandas`, `matplotlib`, `tensorflow`.
`Matplotlib`, вероятно, самая известная библиотека для построения графиков, которая доступна в Python и других языках программирования, таких как R. Именно ее уровень кастомизации и удобства в использовании ставит ее на первое место. Однако с некоторыми действиями и кастомизациями во время ее использования бывает справиться нелегко.
Разработчики создали новую библиотеку на основе `matplotlib`, которая называется `seaborn`. `Seaborn` такая же мощная, как и `matplotlib`, но в то же время предоставляет большую абстракцию для упрощения графиков и привносит некоторые уникальные функции.
В этой статье мы сосредоточимся на том, как работать с `seaborn` для создания первоклассных графиков. Если хотите, можете создать новый проект и повторить все шаги или просто обратиться к моему [руководству по seaborn на GitHub](https://github.com/bajcmartinez/python-seaborn-guide).
### Что такое Seaborn?
[Seaborn](https://seaborn.pydata.org/) — это библиотека для создания статистических графиков на Python. Она основывается на [matplotlib](https://matplotlib.org/) и тесно взаимодействует со [структурами данных pandas](https://livecodestream.dev/post/how-to-work-with-pandas-in-python/).
Архитектура Seaborn позволяет вам быстро изучить и понять свои данные. Seaborn захватывает целые фреймы данных или массивы, в которых содержатся все ваши данные, и выполняет все внутренние функции, нужные для семантического маппинга и статистической агрегации для преобразования данных в информативные графики.
Она абстрагирует сложность, позволяя вам проектировать графики в соответствии с вашими нуждами.
#### Установка Seaborn
Установить `seaborn` так же просто, как и любую другую библиотеку, для этого вам понадобится ваш любимый менеджер пакетов Python. Во время установки `seaborn` библиотека установит все зависимости, включая `matplotlib`, `pandas`, `numpy` и `scipy`.
Давайте уже установим `seaborn` и, конечно же, также пакет `notebook`, чтобы получить доступ к песочнице с данными.
```
pipenv install seaborn notebook
```
Помимо этого, перед началом работы давайте импортируем несколько модулей.
```
import seaborn as sns
import pandas as pd
import numpy as np
import matplotlib
```
#### Строим первые графики
Перед тем, как мы начнем строить графики, нам нужны данные. Прелесть `seaborn` в том, что он работает непосредственно с объектами `dataframe` из `pandas`, что делает ее очень удобной. Более того, библиотека поставляется с некоторыми встроенными наборами данных, которые можно использовать прямо из кода, и не загружать файлы вручную.
Давайте посмотрим, как это работает на наборе данных о рейсах самолетов.
```
flights_data = sns.load_dataset("flights")
flights_data.head()
```
| | **year** | month | passengers |
| --- | --- | --- | --- |
| 0 | 1949 | Jan | 112 |
| 1 | 1949 | Feb | 118 |
| 2 | 1949 | Mar | 132 |
| 3 | 1949 | Apr | 129 |
| 4 | 1949 | May | 121 |
Вся магия происходит при вызове функции `load_dataset`, которая ожидает имя загружаемых данных и возвращает `dataframe`. Все эти наборы данных доступны в [репозитории на Github](https://github.com/mwaskom/seaborn-data).
### Диаграмма рассеяния — Scatter Plot
Диаграмма рассеяния — это диаграмма, которая отображает точки на основе двух измерений набора данных. Создать диаграмму рассеяния в seaborn очень просто, ведь для этого нужна всего одна строчка кода.
```
sns.scatterplot(data=flights_data, x="year", y="passengers")
```
Легко, не правда ли? Функция `scatterplot` принимает в себя набор данных, который нужно визуализировать, и столбцы, которые будут выступать как оси x и y.
### Линейный график — Line Plot
Этот график рисует линию, которая представляет собой развитие непрерывных или категориальных данных. Этот вид графиков популярен и известен, и его легко создать. Как и раньше, мы воспользуемся функцией `lineplot` с набором данных и столбцами, представляющими оси x и y. Остальное за нас сделает `seaborn`.
```
sns.lineplot(data=flights_data, x="year", y="passengers")
```
### Столбчатая диаграмма — Bar Plot
Наверное, это самый известный тип диаграммы, и, как вы уже догадались, мы можем построить этот тип диаграмм с помощью `seaborn`, также, как мы сделали это для линейного графика и диаграммы рассеяния, с помощью функции `barplot`.
```
sns.barplot(data=flights_data, x="year", y="passengers")
```
Она очень красочная, знаю. Позже мы научимся кастомизировать ее.
### Расширение функционала с matplotlib
Seaborn основывается на matplotlib, расширяя ее функциональные возможности и абстрагируя сложность. При этом seaborn не теряет в своей мощности. Любая диаграмма seaborn может быть кастомизирована с помощью функций из библиотеки matplotlib. Эта механика может пригодиться в определенных случаях и позволяет seaborn использовать возможности matplotlib без необходимости переписывать все ее функции.
Допустим, вы хотите построить несколько диаграмм одновременно с помощью seaborn, в этом случае вы можете воспользоваться функцией `subplot` из matplotlib.
```
diamonds_data = sns.load_dataset('diamonds')
plt.subplot(1, 2, 1)
sns.countplot(x='carat', data=diamonds_data)
plt.subplot(1, 2, 2)
sns.countplot(x='depth', data=diamonds_data)
```
С помощью функции `subplot` на одном графике можно построить несколько диаграмм. Функция принимает в себя три параметра: первый – количество строк, второй – количество столбцов, третий – количество диаграмм.
Мы визуализируем по одной диаграмме seaborn на каждой части графика, смешивая функционал matplotlib и seaborn.
### Seaborn и Pandas
Мы уже говорили о том, что seaborn любит pandas до такой степени, что все ее функции строятся на структуре `dataframe`. До этого момента мы использовали seaborn с предварительно загруженными данными, но что, если мы хотим визуализировать данные, которые уже загрузили с помощью pandas?
```
drinks_df = pd.read_csv("data/drinks.csv")
sns.barplot(x="country", y="beer_servings", data=drinks_df)
```
### Создание красивых графиков с помощью стилей
Seaborn дает возможность менять интерфейс ваших графиков. Для этого из коробки у нас в распоряжении есть пять стилей: *darkgrid, whitegrid, dark, white* и *ticks*.
```
sns.set_style("darkgrid")
sns.lineplot(data = data, x = "year", y = "passengers")
```
 А вот другой пример.
```
sns.set_style("whitegrid")
sns.lineplot(data=flights_data, x="year", y="passengers")
```
#### Крутые варианты использования
Мы познакомились с основами seaborn, а теперь давайте применим знания на практике и построим несколько диаграмм с одним и тем же набором данных. В нашем случае вы используем набор данных «*tips*», который можно скачать непосредственно с помощью seaborn.
Сначала загрузим набор данных.
```
tips_df = sns.load_dataset('tips')
tips_df.head()
```
| | **total\_bill** | tip | sex | smoker | day | time | size |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 16.99 | 1.01 | Female | No | Sun | Dinner | 2 |
| 1 | 10.34 | 1.66 | Male | No | Sun | Dinner | 3 |
| 2 | 21.01 | 3.50 | Male | No | Sun | Dinner | 3 |
| 3 | 23.68 | 3.31 | Male | No | Sun | Dinner | 2 |
| 4 | 24.59 | 3.61 | Female | No | Sun | Dinner | 4 |
Мне нравится выводить первые несколько строк набора данных, чтобы получить представление о столбцах и самих данных. Обычно я пользуюсь несколькими функциями pandas, чтобы уладить проблемы с данными, такие как значения `null`, или добавить в набор данных информацию, которая может быть полезной. Подробнее об этом вы можете прочитать в [руководстве к pandas](https://livecodestream.dev/post/how-to-work-with-pandas-in-python/).
Давайте добавим еще один столбец, в котором будет процентное отношение чаевых ко всему счету.
```
tips_df["tip_percentage"] = tips_df["tip"] / tips_df["total_bill"]
tips_df.head()
```
Теперь данные выглядят так:
| | **total\_bill** | tip | sex | smoker | day | time | size | tip\_percentage |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 16.99 | 1.01 | Female | No | Sun | Dinner | 2 | 0.059447 |
| 1 | 10.34 | 1.66 | Male | No | Sun | Dinner | 3 | 0.160542 |
| 2 | 21.01 | 3.50 | Male | No | Sun | Dinner | 3 | 0.166587 |
| 3 | 23.68 | 3.31 | Male | No | Sun | Dinner | 2 | 0.139780 |
| 4 | 24.59 | 3.61 | Female | No | Sun | Dinner | 4 | 0.146808 |
А теперь мы начнем строить графики.
#### Процент чаевых
Давайте попробуем разобраться с процентным соотношением чаевых и счета. Для этого воспользуемся функцией `histplot`, которая сгенерирует гистограмму.
```
sns.histplot(tips_df["tip_percentage"], binwidth=0.05)
```
Чтобы все хорошо читалось, нам пришлось настроить свойство `binwidth`, зато теперь мы быстрее можем понять и оценить данные. Большинство клиентов оставляют чаевые в размере от 15 до 20% от счета, но есть несколько случаев, когда чаевые превышают 70%. Эти значения называются аномалиями или выбросами, и на них всегда стоит обращать внимание, чтобы понять являются ли эти значения ошибочными.
Также мне было интересно, меняется ли процент чаевых в зависимости от времени дня.
```
sns.histplot(data=tips_df, x="tip_percentage", binwidth=0.05, hue="time")
```
На этот раз мы создали диаграмму с помощью всего набора данных, а не одного столбца, и установили свойство `hue` на столбец `time`. Так в диаграмме будут использоваться разные цвета для каждого значения времени, и к ней добавится легенда.
#### Общее количество чаевых за определенный день недели
Еще одна интересная метрика — это количество чаевых, которые получает персонал в зависимости от дня недели.
```
sns.barplot(data=tips_df, x="day", y="tip", estimator=np.sum)
```
Кажется, пятница — хороший день, чтобы остаться дома.
#### Влияние размера столика и дня недели на чаевые
Иногда нужно понять, как несколько переменных влияют на конечный результат. Например, как день недели и размер столика влияют на процент чаевых?
Чтобы построить следующую диаграмму, мы объединим функцию `pivot` из pandas для предварительной обработки, а затем нарисуем тепловую карту.
```
pivot = tips_df.pivot_table(
index=["day"],
columns=["size"],
values="tip_percentage",
aggfunc=np.average)
sns.heatmap(pivot)
```
### Заключение
Конечно, есть еще множество штук, которые мы можем сделать с seaborn, про них вы можете узнать в [официальной документации](https://seaborn.pydata.org/examples/index.html).
Надеюсь, вам понравилась эта статья так же, как и мне. Спасибо за прочтение!
---
> [**Узнать подробнее о курсе**](https://otus.pw/VvSD/) **«Python Developer. Professional».**[**Зарегистрироваться на вебинар**](https://otus.pw/r5LF/) **по теме «Фреймворкирование и метаклассы»**[**.**](https://otus.pw/r5LF/)
>
> | https://habr.com/ru/post/540526/ | null | ru | null |
# Настройка с нуля сервиса управления ИБП Network UPS Tools (NUT) для управления локально подключенным ИБП
Настройка Network UPS Tools на Linux на примере ИБП Eaton 5E650iUSB
===================================================================
Описание
--------
Сервис Linux NUT (Network UPS Tools) — это комплекс программ мониторинга и управления различными блоками бесперебойного питания (далее ИБП). Полный список поддерживаемых моделей можно получить, посмотрев список драйверов в файле */usr/share/nut/driver.list*.
В руководстве описана настройка отключения ПК агентом NUT при потере напряжения в сети на примере ИБП Eaton 5E 650iUSB на Ubuntu-подобных дистрибутивах. Для использования под другие дистрибутивы используйте пакетный мененджер своего дистрибутива или соберите из исходных кодов. Новейшую версию Network UPS Tools можно скачать на GitHub по ссылке [ссылке](https://github.com/networkupstools/nut "github.com/nut").
Установка NUT
-------------
Для начала следует установить NUT:
```
root@hostname~# apt install nut
```
Сделаем резерную копию папки с файлами конфигурации NUT:
```
root@hostname~# cp -r /etc/nut /etc/nut.orig
```
Теперь добавим директиву, указывающую, что ИБП подключен к данному компьютеру, а не к удаленному:
```
root@hostname~# echo "MODE=standalone" > /etc/nut/nut.conf
```
Теперь подключим ИБП к компьютеру и посмотрим вывод команды **lsusb**:
```
root@hostname~# lsusb
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 004: ID 093a:2510 Pixart Imaging, Inc. Optical Mouse
Bus 001 Device 003: ID 1a2c:2124 China Resource Semico Co., Ltd
Bus 001 Device 002: ID 0463:ffff MGE UPS Systems UPS
```
Ищем, поддерживается ли ИБП сервисом NUT. Можно либо просмотреть его вручную либо вывести строки с упоминанием марки ИБП, например:
```
root@hostname~# grep Eaton /usr/share/nut/driver.list
...
"Eaton" "ups" "5" "5E650iUSB" "USB port" "usbhid-ups"
...
```
Теперь, когда мы определились с драйвером, можно настраивать NUT.
### Защита конфигурационных файлов
Следует выставить верные права доступа и владельцев для файлов конфигурации NUT
```
root@hostname~# chown root:nut /etc/nut/*
root@hostname~# chmod 640 /etc/nut/*
```
Настройка NUT
-------------
### Настройка драйвера, способа подключения и времени выключения
Дописываем строки в конец файла */etc/nut/ups.conf* или создаем новый с таким содержимым:
```
root@hostname~# nano /etc/nut/ups.conf
# Имя ИБП в NUT. Именно по нему мы будем посылать команды ИБП
[eaton]
# Используемый драйвер
driver = usbhid-ups
# Порт подключения. Что то менять в ней нужно только для специфических ИБП
port = auto
# Время в секундах до автоматического отключения ПК
offdelay = 90
# Время автоматического включения в минутах после команды отключения ПК
ondelay = 5
# Описание ИБП
desc = "Eaton 5E 650iUSB"
```
### Настройка доступа системной группы NUT к ИБП по USB
Чтобы NUT имел право на доступ к USB интерфейсу ИБП, нужно написать правило доступа для **udev**.
**udev** — подсистема управления устройствами Linux. Благодаря **udev** в папке */dev* находятся только подключенные в данный момент устройства.
Выполним команду
```
root@hostname~# lsusb
```
и найдем строку, соответствующую ИБП. В нашем примере это
```
Bus 001 Device 002: ID 0463:ffff MGE UPS Systems UPS
```
где после **ID** идет **idVendor:idProduct** (**0463:ffff**)
Теперь создадим файл с правилом для **udev**:
```
root@hostname~# /etc/udev/rules.d/90-nut-ups.rules
# Eaton 5E650iUSB
ACTION=="add", SUBSYSTEM=="usb", ATTR{idVendor}=="0463", ATTR{idProduct}=="ffff", MODE="0660", GROUP="nut"
```
После создания правила следует перезагрузить сервис **udev**:
```
root@hostname~# service udev restart
```
После этого следует отключить и заново подключить USB кабель от ИБП. После этого выполним команду для проверки работоспособности **udev** правила:
```
root@hostname~# upsdrvctl start
Network UPS Tools - UPS driver controller 2.7.4
Network UPS Tools - Generic HID driver 0.41 (2.7.4)
USB communication driver 0.33
Using subdriver: MGE HID 1.39
```
Если вывод приблизительно такой, то все настроено правильно.
### Настройка адресов и портов прослушивания подключений к NUT
Дописываем строки в конец файла */etc/nut/upsd.conf* или создаем новый с таким содержимым:
```
root@hostname~# nano /etc/nut/upsd.conf
# Прослушивать Loopback интерфейс на порту 3493
LISTEN 127.0.0.1 3493
```
Имейте в ввиду что LISTEN должно быть написано именно большими буквами, или работать ничего не будет.
### Настройка профиля пользователя для доступа к NUT
Создаем пользователя **upsmonitor** без права логина и домашней папки, с UID меньше 1000, чтобы он считался служебным и его не было на экране входа пользователей в систему, и с GID'ом группы **nut**.
Узнаем GID группы **nut**:
```
root@hostname~# cat /etc/group | grep nut:x:
nut:x:134:
```
Теперь подберем UID для пользователя. Либо выберем такой, какой врядли используется какой либо программой, например, 339, либо выполняем:
```
root@hostname~# cat /etc/passwd | grep [число от 100 до 1000]
```
и если ничего не выводит, то UID свободен и его можно использовать для создания пользователя **upsmonitor**:
```
root@hostname~# useradd -d /dev/null -s /usr/sbin/nologin -u 339 -g 134 -p UPSPASS upsmonitor
```
Теперь добавим этого пользователя в файл профилей пользователей NUT */etc/nut/upsd.users*:
```
root@hostname~# nano /etc/nut/upsd.users
# Имя пользователя
[upsmonitor]
# Пароль пользователя
password = UPSPASS
# Права пользователя на выполение системных действий, то есть выключения и т.д.
actions = SET
# Права на изменение доступных переменных ИБП с помощью команды upscmd
instcmds = ALL
# Использование этого пользователя как управляющего для NUT
upsmon master
```
### Настройки мониторинга NUT
Дописываем строки в конец файла */etc/nut/upsmon.conf* или создаем новый с таким содержимым:
```
root@hostname~# nano /etc/nut/upsmon.conf
# Подключаться к eaton на localhost через учетные данные пользователя upsmonitor
MONITOR eaton@localhost 1 upsmonitor UPSPASS master
# Количество подключенных ИБП
MINSUPPLIES 1
# Путь к программе NUT, которая будет вести широковещательную рассылку
NOTIFYCMD /sbin/upssched
# Частота опроса мониторинга в секундах во время работы от сети
POLLFREQ 5
# Частота опроса мониторинга в секундах во время работы от батареи
POLLFREQALERT 5
# Ожидание отключения дочерних процессов от NUT при завершении работы
HOSTSYNC 15
# Если NUT не может получить отклик от опроса ИБП в течении этого времени то помечает ИБП как "мертвый"
DEADTIME 15
# Специальный флаг, устраняющий проблему, когда питание восстановилось после команды выключения от ИБП к ПК
POWERDOWNFLAG /etc/killpower
# Посылает сообщение о восстановлении питания во все открытые терминалы
NOTIFYMSG ONLINE "UPS %s on line power"
# Посылает сообщение о питании от батареи во все открытые терминалы
NOTIFYMSG ONBATT "UPS %s on battery"
# Посылает сообщение о критическом уровне заряда батареи ИБП во все открытые терминалы
NOTIFYMSG LOWBATT "UPS %s battery is low"
# Посылает сообщение о принудительном выключении во все открытые терминалы
NOTIFYMSG FSD "UPS %s: forced shutdown in progress"
# Посылает сообщение о подключении к ИБП во все открытые терминалы
NOTIFYMSG COMMOK "Communications with UPS %s established"
# Посылает сообщение о потере соединения с ИБП во все открытые терминалы, например, при случайном отключении USB шнура
NOTIFYMSG COMMBAD "Communications with UPS %s lost"
# Посылает сообщение во все открытые терминалы о принудительном выводе из сеансов всех пользователей и выключении ПК после окончания установленного таймера ожидания восстановления питания
NOTIFYMSG SHUTDOWN "Auto logout and shutdown proceeding"
# Посылает сообщение во все открытые терминалы о необходимости замены батареи ИБП
NOTIFYMSG REPLBATT "UPS %s battery needs to be replaced"
# Посылает сообщение во все открытые терминалы об отсутствии доступа к ИБП
NOTIFYMSG NOCOMM "UPS %s is unavailable"
# Посылает сообщение во все открытые терминалы о завершении процесса программы мониторинга NUT upsmon
NOTIFYMSG NOPARENT "upsmon parent process died - shutdown impossible"
# Выполнение действий по наступлению события, указанного после NOTIFYFLAG.
# SYSLOG это отправка сообщения о событии в логи ПК, в файл /var/log/syslog
# WALL это отправка сообщения о событии во все открытые терминалы
# EXEC это выполнение команды, определенной в файле /etc/nut/upsshed.conf, при наступлении события
NOTIFYFLAG ONLINE SYSLOG+WALL+EXEC
NOTIFYFLAG ONBATT SYSLOG+WALL+EXEC
NOTIFYFLAG LOWBATT SYSLOG+WALL+EXEC
NOTIFYFLAG FSD SYSLOG+WALL+EXEC
NOTIFYFLAG COMMOK SYSLOG+WALL+EXEC
NOTIFYFLAG COMMBAD SYSLOG+WALL+EXEC
NOTIFYFLAG SHUTDOWN SYSLOG+WALL+EXEC
NOTIFYFLAG REPLBATT SYSLOG+WALL+EXEC
NOTIFYFLAG NOCOMM SYSLOG+WALL+EXEC
NOTIFYFLAG NOPARENT SYSLOG+WALL+EXEC
# Время вывода сообщения о необходимости замены батареи ИБП в секундах (12 часов)
RBWARNTIME 43200
# Если NUT не может святься с настроенными ИБП, то посылает событие NOCOMM каждые 300 секунд
NOCOMMWARNTIME 300
# Последний интервал ожидания перед выключением системы
FINALDELAY 5
```
### Тест соединения
Посмотрим, что ИБП может сообщить о своем состоянии:
```
root@hostname~# upsc eaton@localhost
battery.charge: 100
battery.runtime: 1964
battery.type: PbAc
device.mfr: EATON
device.model: 5E 650i
device.type: ups
driver.name: usbhid-ups
driver.parameter.offdelay: 60
driver.parameter.pollfreq: 30
driver.parameter.pollinterval: 2
driver.parameter.port: auto
driver.parameter.synchronous: no
driver.version: 2.7.4
driver.version.data: MGE HID 1.39
driver.version.internal: 0.41
input.voltage: 228.0
outlet.1.status: on
outlet.desc: Main Outlet
outlet.id: 1
outlet.switchable: no
output.frequency: 50.0
output.frequency.nominal: 50
output.voltage: 226.0
output.voltage.nominal: 230
ups.beeper.status: enabled
ups.delay.shutdown: 60
ups.firmware: 03.08.0018
ups.load: 18
ups.mfr: EATON
ups.model: 5E 650i
ups.power.nominal: 650
ups.productid: ffff
ups.start.battery: yes
ups.status: OL
ups.timer.shutdown: -1
ups.vendorid: 0463
```
Все поля более менее очевидны или были определены нами в конфигурационных файлах ранее. Коды состояний ИБП отображаются в поле **ups.status:** и могут принимать значения:
* OL — система работает от сети;
* OB — система работает от батареи;
* LB — система работает от разряженной батареи.
### Внутренние команды и переменные ИБП
ИБП можно давать команды напрямую из консоли, с помощью команды **upscmd**. Список доступных команд можно получить, выполнив команду:
```
root@hostname~# upscmd -l eaton@localhost
Instant commands supported on UPS [eaton]:
beeper.disable - Disable the UPS beeper
beeper.enable - Enable the UPS beeper
beeper.mute - Temporarily mute the UPS beeper
beeper.off - Obsolete (use beeper.disable or beeper.mute)
beeper.on - Obsolete (use beeper.enable)
load.off - Turn off the load immediately
load.off.delay - Turn off the load with a delay (seconds)
shutdown.stop - Stop a shutdown in progress
```
Настройки **beeper.\*** управляют сигнализацией ИБП в случае потери напряжения в сети, **load.off** выключает ПК немедленно, **load.off.delay** задержка в секундах до выключения ПК, **shutdown.stop** — команда прерывания процесса отключения ПК.
В некоторых ИБП присутствуют и другие опции, например, тест батареи или **shutdown.return**, в случае использования которой компьютер будет выключен, но ИБП пошлет сигнал включения ПК как только восстановится питание в сети. Чтобы это сработало, в БИОСе ПК дожна быть включена соответствующая функция, которая обычно находится где то в районе настроек питания.
Для примера выключим писк ИБП, когда пропадает питание в сети:
```
root@hostname~# upscmd -u upsmonitor -p UPSPASS eaton@localhost beeper.disable
```
Чтобы включить, замените **beeper.disable** на **beeper.enable**.
### Настройка планировщика задач NUT upssched
Дописываем строки в конец файла */etc/nut/upssched.conf* или создаем новый с таким содержимым:
```
root@hostname~# nano /etc/nut/upssched.conf
# Скрипт, откуда будут выполнятся команды по событиям
CMDSCRIPT /etc/nut/cmd.sh
PIPEFN /tmp/upspipe
LOCKFN /tmp/upslock
# Условия выполнения команд из case конструкции в скрипте /etc/nut/cmd.sh
AT COMMBAD * EXECUTE commbad
AT COMMOK * EXECUTE commok
AT NOCOMM * EXECUTE nocomm
# Указание включить ПК после восстановления питания. Можно удалить или закомментировать если не поддерживается ИБП
AT ONBATT * EXECUTE powerout
# Запуск таймера, после окончания которого выполнится команда shutdownnow из cmd.sh
AT ONBATT * START-TIMER shutdownnow 90
AT LOWBATT * EXECUTE shutdowncritical
AT ONLINE * CANCEL-TIMER shutdownnow
AT ONLINE * EXECUTE powerup
```
Теперь теперь нужен скрипт */etc/nut/cmd.sh*. Создадим его, выставим права и заполним его:
```
root@hostname~# touch /etc/nut/cmd.sh
root@hostname~# chmod 666 /etc/nut/cmd.sh
root@hostname~# nano /etc/nut/cmd.sh
#!/bin/sh
# logger посылает указанный текст в syslog
case $1 in
commbad)
logger "UPS communications failure"
;;
commok)
logger "UPS communications restored"
;;
nocomm)
logger "UPS communications cannot be established"
;;
powerout)
# Выключает ПК с задержкой в указанное количество секунд
logger "UPS on battery. Shutdown in 90 seconds...."
upscmd -u upsmonitor -p UPSPASS eaton@localhost shutdown.return
;;
shutdownnow)
logger "UPS has been on battery for 120 seconds. Starting orderly shutdown"
# Запуск принудительного выключения ПК
upsmon -c fsd
;;
shutdowncritical)
logger "UPS battery level CRITICAL. Shutting down NOW!!!!"
# Запуск принудительного выключения ПК
upsmon -c fsd
;;
powerup)
logger "UPS on line. Shutdown aborted."
# Прерывание процесса выключения ПК
upscmd -u upsmon -p pass mustek@localhost shutdown.stop
;;
*)
logger "Unrecognized command: $1"
;;
esac
```
### Заключение
На этом настройка завершена. Можно протестировать, банально выдернув ИБП из розетки. | https://habr.com/ru/post/443736/ | null | ru | null |
# Сервис push-уведомлений Pushover для Android и iOS в связке с PHP
Вкратце, **push-уведомления** — это небольшие по объему важные сообщения от программы или сервиса, отображаемые операционной системой тогда, когда вы непосредственно не работаете с указанным приложением или сервисом. Преимущество таких уведомлений в отсутствии необходимости держать программу вечно в памяти, тратя на нее процессорные мощности и память.
Не буду здесь расписывать всю технологию доставки удаленного уведомления, ибо это уже [сделано](http://habrahabr.ru/company/ruswizards/blog/156811/) [до меня](http://habrahabr.ru/post/116106/). Выглядит примерно так: периодически демон опрашивает сервер и в случае появления сообщения, показывает его нам.
Для iOS придумали [APNS](http://developer.apple.com/library/mac/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/ApplePushService/ApplePushService.html), для Android-а — [C2DM-GCM](http://developer.android.com/guide/google/gcm/index.html), я же хочу рассказать про кроссплатформенный (громко) сервис [Pushover](https://pushover.net/) и связке его с php-сайтом.
#### Пример задачи
Предположим, что раз в день мы хотим знать что-либо о количестве заказов на сайте за день и их стоимости.
Сайт крутится на некоторой CMS на PHP и mySQL, принимающая сторона имеет стильные iPhone и Android-телефоны.
Срочность доставки сообщения не относится к жизненно-важным показателям.
Надо найти условно безгеморройное решение.
#### Pushover
Pushover — это скромный [сервис уведомлений](https://pushover.net), а также приложения для [iOS](https://itunes.apple.com/us/app/pushover-notifications/id506088175?ls=1&mt=8) и [Android](https://play.google.com/store/apps/details?id=net.superblock.pushover&ts=1353482264), планируются поделки и для BlackBerry и OS X Mountain Lion. Сервис имеет свой [API](https://pushover.net/api), позволяет отправлять бесплатно до 7.5 тысяч сообщений в месяц.
Сообщение, помимо основного текста сообщения длиной 512 символов, может содержать крупный заголовок, URL (тогда длина сообщения увеличивается до 500) и его тайтл (все отображается отдельными сформированными блоками, потому такое разграничение). Сообщение можно доставить под неким выбранным указанным приоритетом. Пользователь может указать «тихие» часы, когда его не стоить будить уведомления, а также подключать и отключать устройства, на которые будут приходить уведомления.
Уведомление может быть доставлено пользователям, предоставившим свой код, всем устройствам этого пользователя или по выбору. Для приема сообщения пользователю необходимо быть зарегистрированным в сервисе и обладать хотя бы одним рабочим устройством.
##### Добавление пользователя
После прохождения [регистрации](https://pushover.net/login), каждый пользователь попадает в свой кабинет, где он сразу видит свой хэш-токен. Это уникальный идентификатор пользователя, на который в последствии и отправляются уведомления.
Пользователю, желающему принимать сообщения, необходимо поставить на свой телефон/планшет/абы что приложение из соответствующего магазина.
##### Добавление сервиса
Добавление сервиса ничуть не сложнее. Из личного кабинета надо перейти на [страницу](https://pushover.net/apps/build) создания приложения, где предлагается описать продукт:
После заполнения соответствующих полей, нам становится известен токен приложения. В принципе, это все, что необходимо для отправки сообщения.
На странице приложения в последующем будет красивый график успешно отправленных сообщений.
##### Связывание приложений и получателей
… не выполняется никак. Любое приложение может отправить любому пользователю уведомление, если знает его токен. Прием токенов от населения остается на совести приложения. Также как и отписка от рассылок.
##### API
[Небольшое](https://pushover.net/api), емкое и понятное. Для отправки сообщения в POST-запросе к *[api.pushover.net/1/messages.json](https://api.pushover.net/1/messages.json)* или *[api.pushover.net/1/messages.xml](https://api.pushover.net/1/messages.xml)* минимально необходимо указать:
* **token** — хэш-токен вашего приложения или сервиса.
* **user** — хэш-токен пользователя, которому вы отправляете уведомление.
* **message** — текстовая часть сообщения.
Дополнительно к этому можно добавить:
* **device** — идентификатор устройства пользователя, дабы не отсылать уведомления сразу на все его устройства
* **title** — заголовок сообщения, если не указан, будет показано название сервиса
* **url** — ссылка на web-страницу, если в этом есть необходимость
* **url\_title** — заголовок к ссылке
* **priority** — приоритет сообщения, ставится в 1 для высокого приоритета, обходящего все «тихие» часы и -1 для тихого уведомления.
* **timestamp** — UNIX метка времени, когда это уведомлениебыло создано. Расписания доставки сообщений сервисом не предусмотрено.
##### Ответ сервера
Ответ сервера будет представлен в json или xml формате (в зависимости от расширения вызываемого скрипта).
Если все прошло удачно будет отдан объект содержанием поля *status*, равном 1.
Иначе, поле *status* будет содержать нечто иное, а поле *errors* — массив описания ошибок. Вот примеры ответов удачной и неудачной отправок в формате XML:
```
xml version="1.0" encoding="UTF-8"?
1
```
и
```
xml version="1.0" encoding="UTF-8"?
invalid
application token is invalid
0
```
#### PHP
На главной странице и в факе в разделах «смотрите, как легко!» приводятся коды простейшего скрипта на различных языках для отправки и есть ссылка на 3rd-party [php-класс](https://github.com/kryap/php-pushover) от Chris Schalenborgh.
Везде используется сURL, что впрочем, понятно.
##### Зафигарим свой класс
Куда ж нынче без велосипедов?
На самом деле, мне не слишком понравилось, что успех отправки уведомления определяется либо как true/false, либо выводится сразу вся простыня ответа сервера. Да вообще обработки ошибок нет. Считаю, что если посетителю сайта не обязательно, то разработчику надо знать, почему не отправлено то или иное сообщение.
В общем, существенно меняем все, классы уехали на [GitHub](https://github.com/Urvin/pushover).
**class PushoverException**
```
class PushoverException extends Exception
{
/**
* Messages array
* @var array
*/
private $fMessages;
/**
* Exception constructor
* @param array $aMessages An array of messages
*/
public function __construct(array $aMessages)
{
parent::__construct('PushoverException exception');
$this->fMessages = $aMessages;
}
/**
* Get messages array
* @return array
*/
public function getMessages()
{
return empty($this->fMessages) ? array() : $this->fMessages;
}
}
```
**class Pushover**
```
class Pushover
{
/*
* Pushover json api service url
*/
const C_API_URL = 'https://api.pushover.net/1/messages.json';
/**
* Properties storage array
* @var array
*/
private $fProperties;
/**
* cURL instance
*/
private $fCurl;
//--------------------------------------------------------------------------//
/**
* Properties getter
* @param string $aPropertyName Property name
* @return mixed
*/
public function __get($aPropertyName)
{
if(array_key_exists($aPropertyName, $this->fProperties))
return $this->fProperties[$aPropertyName];
return null;
}
/**
* Properties setter
* @param string $aPropertyName Property name
* @param mixed $aValue Property value
*/
public function __set($aPropertyName, $aValue)
{
$this->fProperties[$aPropertyName] = $aValue;
}
//--------------------------------------------------------------------------//
/**
* Class constructor
* @param string $aApplicationToken Application token
*/
public function __construct($aApplicationToken = null)
{
if(!empty($aApplicationToken))
$this->applicationToken = $aApplicationToken;
$this->fCurl = curl_init();
curl_setopt($this->fCurl, CURLOPT_URL, self::C_API_URL);
curl_setopt($this->fCurl, CURLOPT_HEADER, false);
curl_setopt($this->fCurl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($this->fCurl, CURLOPT_SSL_VERIFYPEER, false);
}
/**
* Class destructor
*/
public function __destruct()
{
curl_close($this->fCurl);
}
//--------------------------------------------------------------------------//
/**
* Throws an exceprion with single message
* @param mixed $aMessage
* @throws PushoverException
*/
public function throwMessage($aMessage)
{
throw new PushoverException(array($aMessage));
}
/**
* Throws an exceprion with an array of messages
* @param array $aMessages
* @throws PushoverException
*/
public function throwMessages(array $aMessages)
{
throw new PushoverException($aMessages);
}
//--------------------------------------------------------------------------//
/**
* Send pushover notification
*/
public function send()
{
if(!strlen($this->applicationToken))
$this->throwMessage('Application token is empty');
if(!strlen($this->userToken))
$this->throwMessage('User token is empty');
if(!strlen($this->notificationMessage))
$this->throwMessage('Notification message is empty');
if(intval($this->notificationTimestamp) <= 0)
$this->notificationTimestamp = time();
$lSendParams = array(
'token' => $this->applicationToken,
'user' => $this->userToken,
'device' => $this->userDevice,
'title' => $this->notificationTitle,
'message' => $this->notificationMessage,
'priority' => $this->notificationPriority,
'timestamp' => $this->notificationTimestamp,
'url' => $this->notificationUrl,
'url_title' => $this->notificationUrlTitle
);
foreach($lSendParams as $lKey => $lParam)
if(empty($lParam))
unset($lSendParams[$lKey]);
curl_setopt($this->fCurl, CURLOPT_POSTFIELDS, $lSendParams);
$lResponseJson = curl_exec($this->fCurl);
if($lResponseJson === false)
$this->throwMessage('API request error');
$lResponse = json_decode($lResponseJson, true);
if(empty($lResponse) || !is_array($lResponse))
$this->throwMessage('Bad API response');
if(!empty($lResponse['errors']))
$this->throwMessages($lResponse['errors']);
if(empty($lResponse['status']) || intval($lResponse['status']) != 1)
$this->throwMessage('Unknown notification send error');
}
}
```
Минимальное сообщение теперь довольно просто отправить, ошибки можно разбирать:
```
$lPushover = new Pushover('Токен приложения');
$lPushover->userToken = 'Токен пользователя';
$lPushover->notificationMessage = 'Текст сообщения';
try
{
$lPushover->send();
echo 'Message sent', PHP_EOL;
}
catch (PushoverException $aException)
{
echo 'Error sending messages
', PHP_EOL;
echo '', PHP\_EOL;
foreach($aException->getMessages() as $lMessage)
echo '* ', $lMessage, '
', PHP\_EOL;
echo '
', PHP_EOL;
}
``` | https://habr.com/ru/post/159649/ | null | ru | null |
# Аналог фейсбучной ленты для Телеграма. Тупенький ИИ OLEG
Этот пост — о том, как я решил сделать систему коллаборативной фильтрации постов из пабликов Телеграма на основе машинного обучения.
И сделал: [OLEG AI](http://t.me/olegaibot)
Идея
----
В мире наступает революция ИИ, и в какой то момент мне стало казаться, что без меня она наступить не сможет. Поэтому я нашел курс по программированию нейросетей на Питоне [Fast.AI](https://course.fast.ai/), и решил придумать себе небольшой проект, чтобы поучиться на практике.
Я люблю Телеграм. И люблю иногда потупить в какую-нибудь ленту "информационного корма". В разное время я любил поразлагаться на Лепре, Дёти, Пикабу, но в итоге всеми этими источниками сладкого яда я остался недоволен.
И тогда я подумал: в Телеграме ведь куча источников, но Телеграм их не агрегирует по типу Фейсбука. Телеграм не собирает с нас лайки. Да, лайки это чистое зло и гореть им в аду, но иногда так хочется лайкнуть жопу фотомодели, нет?
А рекомендательные сервисы — это одно из направлений ML. А Телеграм — открытая система. Должно быть не сложно, подумал я. Оказалось чуть сложнее чем я думал, но получилось.
Стоит заметить, что я не профессиональный программист, и опыта в программировании у меня не было примерно с 2004 года. Так что, помимо собственно нейросетей, мне пришлось еще и быстренько расчухать основы Питона, вспомнить SQL, погрузиться в Докер и практику CI/CD. Это было потрясающе.
Процесс
-------
Начал я с того, что убедился, что задуманное мной в принципе возможно.
Мне нужно было слушать некий набор каналов (пабликов) Телеграма, и передавать посты подписчикам бота. Поизучал доки Telegram Bot API, понял, что при помощи одного только Telegram Bot API сделать это не получится. Бот не может подписываться на каналы по своему выбору.
Придется писать своего клиента для Telegram. К счастью, с нуля писать не пришлось: есть неплохая основа в виде либы [python-telegram](https://github.com/alexander-akhmetov/python-telegram). Апишка там не самая проработанная, но самое тяжелое она делает за нас: процесс логина, предоставляет классы для создания запросов и получения асинхронных ответов от TDLib. TDLib это сишная либа-Телеграм-клиент. Так что я вооружился доками от [TDLib](https://core.telegram.org/tdlib/docs), и принялся ковырять ее. Заодно разобрался как работает Телеграм, прикольно.
Я завел доску miro.com, чтобы накидывать туда идеи, рисовать схемы. Например, схему БД я нарисовал там. Оказалось очень удобно для маленького проекта — всё в одном месте и в то же время не мешает.
Как я представлял себе то, что хочу сделать:
Довольно быстро я накидал приложение, схема которого в итоге оказалась примерно такой:
Блоки — объекты.
Тут не все объекты, конечно, а только основные.
**Admin** — это обычный аккаунт Телеги, залогиненный через TDLib и подписанный на интересующие нас каналы. Слушает апдейты каналов и записывает. Причем он не пишет контент, а только метаданные сообщения: tg\_channel\_id и tg\_msg\_id. По этим двум полям можно найти любое сообщение в Телеге (если оно было показано аккаунту).
**Bot** — аккаунт бота, общение с которым тоже происходит через TDLib (до этого я даже не знал, что так можно, думал, что только через Bot API можно работать с ботом).
К ним подключены **TDLibUtils** — всякие методы для работы с TDLib низкого уровня. Типа, найти юзера, найти сообщение, вытащить имя канала из инфы о канале и тп.
**OlegDBAdapter** — методы для работы с базой (get\_users, get\_posts etc)
**OlegNN** — то, ради чего всё затевалось — алгоритм коллаборативной фильтрации. Правда, по итогу никакой нейросети там внутри не осталось, но об этом позже.
**Joiner** — логика подписки на каналы. Нельзя так просто взять список каналов и подписаться на него: быстро срабатывает рейт лимитинг. На вычисление безопасной логики подписки, логирование, организацию базы ушло около недели.
**APScheduler** — сторонняя либа-планировщик тасков. Использую для периодической рассылки сообщений подписоте.
### Контент
Схемы работы с контентом могло быть две:
* забирать контент каждого сообщения, хранить его, и собирать из него сообщение для подписчика по запросу. Плохо, тк придется качать и хранить кучу контента. Ладно бы текст, но там еще и медиа
* не хранить контент, а забирать его из Телеграма по необходимости
+ в идеале — не выкачивать медиа, а придумать, как его передавать юзеру прямо внутри Телеграма. Этот вариант и реализовал, правда, пришлось помаяться.
Чтобы не выкачивать медиа, в Телеграме у каждого ассета есть свой уникальный айди. Когда собираешь сообщение, можно вместо файла указать этот айди. Я думал, что этого достаточно, но посты не отправлялись. Оказалось, дело в том, что аккаунт отправляющий медиа с помощью айдишника, должен сначала этот айдишник встретить в Телеграме. Например, получить сообщение с этой картинкой. Проблема в том, что у меня за получение сообщений отвечает аккаунт Admin, а за отсылку — Bot. Я долго думал, и в итоге придумал: а что, если каждое полученное сообщение Админ будет форвардить Боту, таким образом Бот "увидит" всё медиа. Это сработало. Я боялся, что за такое количество форвардов поймаю рейтлимит и огребу гемморой, обходя это дело, но в итоге обошлось.
### Каналы
Не мудрствуя лукаво, я купил список топовых каналов по количеству подписчиков у TGStat.ru. 45 категорий по 100 каналов, вышло 4500 каналов. Пока этого хватает, возможно допишу еще паука, который сам лезет в каналы упомянутые в постах, и подписывается на них. Я сразу сделал логику Joiner'а так, чтобы можно было легко докинуть ему в пул свежих каналов, а он с ними сам разберется.
С каналами уперся в неожиданный лимит: один аккаунт Телеграма может быть подписан только на 500 каналов. Придется теперь превращать Admin'а в хаб, управляющий несколькими аккаунтами, и добавлять аккаунты, следить какой аккаунт подписан на какой канал, и всё в таком духе. Пока отложил это, решил, что для старта 500 каналов хватит.
Нейросеть, которой нет
----------------------
Затевал я всё это ради практики программирования нейросетей, как вы помните.
Когда внедряешь машинное обучение, сталкиваешься с тем, что это всё-таки черный ящик, у которого наружу торчат некие гиперпараметры, а на выходе получается какой-то результат, причем, если при разработке ты правильно учел всякие там размерности тензоров и не наделал глупых ошибок, оно будет работать. Как-то будет. Будет ли результат, выдаваемый ящиком, иметь какой-то смысл — это вопрос. Чтобы ответить на этот вопрос, приходится сидеть, расковыривать ее так и эдак, смотреть на результаты разных этапов вычисления, читать тематические статьи, узнавать практику, прикидывать baseline результат и сравнивать с тем, что получилось у тебя. Короче, это весело. На первых этапах машинное обучение создает гораздо больше проблем, чем решает. И заставить его реально решать какие то проблемы, создавая прибавленную стоимость для вашего проекта — большая работа, не очень похожая на обычное программирование и дебаг.
Так что трижды подумайте, прежде чем бросаться решать проблемы этим методом. ML требует жирных проблем, которые точно не решаются классическими методами и сулят повышенный профит. **ML ради ML истощает бюджеты и роняет мораль!**
Прежде чем прикрутить ML к Олежке, я долго крутил системы коллаборативной фильтрации на тренировочном датасете MovieLens (*ой, только не надо*).
Я делал решение как для задачи регрессии (в конце один нейрон который угадывает рейтинг фильма по шкале 1..5), так и для задачи классификации (в конце 5 нейронов, каждый отвечает за свой рейтинг 1..5, и какой нейрон сильнее активируется, тот рейтинг мы и считаем за предсказание).
Эти изыскания заняли прилично времени, кажется 2-3 недели. По ходу дела я даже с нуля написал классификатор MNIST, благодаря чему сильно продвинулся в понимании работы нейронок. Кто еще не делал этого: очень рекомендую. Времени занимает от силы 2 дня, а пользу приносит годами.
В итоге стало ясно, что если задачу рассматривать как регрессию (а не классификацию), предсказательная сила модели будет намного лучше, так я и сделал.
В основе механизма у меня эмбеддинги. Кто не в курсе — читаем дальше, кто знает — может промотать следующий раздел.
### Embeddings
Идея простая, но гениальная: каждой сущности (юзеру, посту) противопоставляется вектор параметров. Например, K=10 параметров. Они еще называются латентные факторы (latent factors).
Получается, что если у нас N юзеров, то мы можем расположить все вектора друг под другом, и получить тензор формы (N,K). Матрицу из N рядов и K колонок, если по-колхозному.
Для постов получится такой же тензор, только другой.
Эти тензоры называются эмбеддингами.
Cистема спрашивает у алгоритма фильтрации: вот есть юзер U, пост P, предскажи мне рейтинг, который юзер поставит посту.
В самом простом варианте (без нейронки) мы ищем в тензоре юзеров нужный ряд соответствующий юзеру, в тензоре постов — вектор поста, и перемножаем эти два вектора (как в школе). На выходе получается скаляр (число) — это и есть предсказанный рейтинг.
В варианте посложнее, эти два вектора подаются на вход нейросети, и дальше сигнал продвигается уже механизмом нейросети. На выходе — один нейрон, величина активации которого — скаляр — и есть предсказанный рейтинг.
Почему эти тензоры назвали отдельным словом "эмбеддинг", что в них особенного? Дело в том, что эмбеддинг — это первый шаг вычисления результата работы нейронки.
Когда мы ищем нужный ряд для юзера или поста в тензоре, мы могли бы просто взять индекс нужного ряда, и вытащить вектор соответствующий этому индексу. Но операция "взять ряд по индексу" не является алгебраической, это программатик-операция работы с памятью. Это означает, что данная операция разрывает граф вычислений градиента нейросети. Градиент можно вычислить только для алгебраических операций. То есть, во время обучения механизм back propagation не сможет дойти до самого конца — непосредственно до эмбеддинга. Как же быть?
Вместо того, чтобы брать ряд тензора по индексу, мы можем умножить этот тензор на one-hot-encoded vector. Например, нам нужен третий по счету ряд тензора. Умножаем тензор на вектор [0 0 1 0 ...] На выходе получаем нужный нам ряд тензора. Это алгебраическая операция (умножение тензора на тензор), она не ломает граф вычислений! Но это компутационно дорогая операция. Каждый раз так умножать GPU замучается. Поэтому в PyTorch и других пакетах нейровычислений есть специальный компутационный шорткат для эмбеддингов, который с одной стороны и граф вычислений не ломает, и компутационно дешев.
Где же взять эмбеддинги?
Допустим, у нас есть обучающий датасет: энное количество оценок, которые юзеры поставили постам.
Давайте проинициализируем эмбеддинги случайным образом, и для каждой оценки из датасета будем вычислять предсказание и сравнивать с оценкой. У нас получатся некие дельты, на этих дельтах мы и будем обучать нейросеть и эмбеддинги с помощью стохастического градиентного спуска (SGD).
В итоге через несколько эпох обучения (эпоха — проход всего датасета) наши эмбеддинги из случайных превратятся в обученные, и будут иметь некий смысл.
Каждый из параметров эмбеддинга действительно приобретает некий смысл. Какой — не совсем понятно, да и не нужно понимать. Будем считать, что этот смысл ведом только самой системе рекомендаций. Для нас главное, что в итоге система работает: рекомендует юзерам более релевантные посты. А какой "смысл" она видит в этих постах — какая разница?
#### Длина вектора латентных параметров
Число параметров K — какое оно должно быть? Лучший ответ, что мне удалось найти, был в этой статье: [A social recommender system using item asymmetric correlation](https://www.researchgate.net/publication/318622448_A_social_recommender_system_using_item_asymmetric_correlation).
Если коротко, единого ответа нет, всё зависит от глубины сложности ваших item'ов, постановки задачи, функции потерь, короче, от всего. Rule of thumb: 5 — маловато, 50 — многовато, где-то посередине — в самый раз. Надо пробовать: смотреть, насколько гладко обучается модель, не провоцирует ли выбранное количество параметров переобучение, обучается ли модель вообще.
Я выбрал K=13
### Где нейросеть?
Поиграв некоторое время с разными конфигурациями, я понял что для моей задачи регрессии оценки в диапазоне 0..1 лучше всего подходит конфигурация без нейросети. У меня просто перемножаются эмбеддинги. В таком варианте, без глубинного обучения, обучение происходит гораздо быстрее и плавнее. В данном случае проще оказалось лучше.
### Обучение
Самый большой мой просчёт в архитектуре был связан с тем, что я думал, будто результаты обучения — очень ценная инфа, и её надо хранить персистентно, на диске в виде бинарника или в базе. Я написал код, который сохраняет вектора для каждого поста и юзера в базу в виде BLOB'а. Написал, потестил время выполнения, оказалось, что процесс обучения занимает 1-2 секунды, а процесс записи результатов — около минуты. Сама модель занимает в памяти 52 мегабайта для 1 млн постов. Так и зачем вообще сохранять ее в памяти? В любой момент можно обучить ее с нуля за пару секунд. Пришлось переписать.
Вот так выглядит процесс обучения. По вертикали — ошибка, по горизонтали — номер мини-батча:
Мини-батч — это некоторое число оценок, которые одновременно подаются на вход модели для обучения. В моем случае `batch_size = 512`.
Каждый пик — это старт обучения с нуля. Видно, как по мере обучения падает ошибка.
Вот так выглядит инференс (процесс предсказания) модели:
Каждая точка — это пост из базы. По вертикали — предсказанная оценка. Из 11 115 постов всего 338 имеют предсказанную оценку выше 1, из них в итоге модель и выберет тот пост, который попадет юзеру в ленту.
#### Обучение с нуля и инкрементное обучение
Когда переходишь от игрушечных моделей для учебы к реальной модели для проекта, возникают вопросы:
* Как быть, если приходит новая оценка от юзера? Стартовать обучение сразу, или ждать N новых оценок?
* При получении новой оценки, обучать модель "на старые дрожжи" (инкрементно), то есть взять те веса и эмбеддинги, которые есть, и на них натравить датасет из новых оценок? Или просто переобучить всё с нуля?
Когда передо мной встали эти вопросы, беглый поиск ответов мне ничего не принес, поэтому я вооружился здравым смыслом и практикой. Соображения у меня были такие:
* Инкрементное обучение плохо тем, что если запускать только его, и никогда не обучать с нуля, параметры застревают в некой области значений. Кривая обучения становится очень резкой. На практике это означает, что при поступлении новых данных и запуске инкрементного обучения, несколько эпох ошибка почти не меняется, потом делает резкий скачок вниз или вверх, и потом опять стоит как вкопанная. Это — очень нездровая ситуация, если вы столкнулись с таким, ищите как сделать обучение гладким, вплоть до переформулирования задачи как таковой.
* Обучение "с нуля" почти ничего нам не стоит, поэтому не надо этого стесняться.
* Глядя в будущее, можно предположить, что когда-нибудь у Олежки скопится датасет из 1 млн оценок, который будет занимать заметное время на обучение (десятки секунд). Юзеров будет достаточно много, и при получении каждой новой оценки запускать обучение с нуля мы не сможем.
Поэтому я сделал интерфейс и для инкрементного обучения, и для обучения с нуля. И написал логику, которая запускает полное обучение раз в N циклов инкрементного. А также сделал таймаут между циклами обучения. Всё это вынесено в конфиг. По мере взросления сервиса я смогу легко поменять эти настройки.
Холодный старт и взросление сервиса
-----------------------------------
Если вам доводилось читать о рекомендательных системах, вам должно быть известно, что одной из самых больших проблем в них является "холодный старт" и бутсртап свежего юзера. Холодный старт — это когда в системе в принципе мало оценок, а свежий юзер — это юзер, о вкусах которого мы ничего пока не знаем.
Действительно, если в системе мало оценок (и много постов), как ее ни обучай, данных будет недостаточно, чтобы выученные эмбеддинги имели какой-то смысл. Рекомендации продуцируемые этой системой будут малорелевантными.
Со свежим юзером похожая проблема.
Как решить эти вопросы? Единого решения не существует. Все пользуются здравым смыслом и той информацией, которая доступна.
Например, для свежего юзера мы можем сделать некий опросник (так сделано в Netflix), который сможет быстро сообщить нам хоть что-то о юзере, чтобы сделать первый опыт пользования системой не ужасным.
Я решил, что опросник для Олежки будет слишком тяжеловесным решением, юзеры хотят просто тыкать лайки, а не отвечать на вопросы типа "ваш любимый цвет". Поэтому я решил так: первые 30 постов, которые Олежка присылает юзеру, я выбираю из числа тех, которые максимально нравятся всем. Говоря строго, они имеют максимальный bias.
Железо
------
Сейчас Олежка работает на самом дешевом инстансе Digital Ocean ($5/мес), без GPU. База расположена на этом же инстансе, в другом докер-контейнере. Думать о скейлинге пока рановато.
Итог
----
Олежка стабильно работает, перестал жрать память и чувствует себя хорошо.
Юзеров пока маловато, так что, пожалуйста, лайк-шер. Можно просто шерить посты из ленты друзьям в Телеграме.
Больше юзеров — релевантнее рекомендации! | https://habr.com/ru/post/555726/ | null | ru | null |
# Поваренная книга разработчика: DDD-рецепты (5-я часть, Процессы)
Введение
========
В рамках предыдущих статей мы описали: [область применения](https://habr.com/post/426663/), [методологические основы](https://habr.com/post/428209/), [пример архитектуры](https://habr.com/ru/post/429750/) и [структуры](https://habr.com/ru/post/435920/). В данной статье, я хотел бы рассказать как описывать процессы, о принципах сбора требований, чем отличаются бизнес требования от функциональных, как перейти от требований — к коду. Рассказать о принципах применения *Вариантов Использования* (Use Case) и как они нам могут помочь. Разобрать на примерах варианты реализации шаблонов проектирования Interactor и Service Layer.
Примеры приведенные в статье даны с использованием нашего решения [LunaPark](http://lunapark.dev), оно поможет вам с первыми шагами в описанных подходах.
Отделяем функциональные требования от бизнес требований.
========================================================
Снова и снова случается так, что многие бизнес-идеи на самом деле не превращаются в конечный, намеченный продукт. Зачастую это происходит из-за неспособности понять разницу между бизнес-требованиями и функциональными требованиями, что в конечном итоге, приводит к несоответствующему сбору требований, ненужной документации, задержкам проекта и крупным проектным сбоям.
Или иногда мы сталкиваемся с ситуациями, в которых, хотя окончательное решение отвечает потребностям клиентов, но каким-то образом бизнес-цели не достигаются.
Поэтому крайне важно разделить бизнес-требования и функциональные требования, до того момента, как вы начнете их определять. Давайте разберем пример.
Предположим, мы пишем приложение для компании по доставке пиццы, и мы решили сделать систему по отслеживанию курьеров. Бизнес требования звучат следующим образом:
*"Внедрить веб-систему и систему отслеживания сотрудников на базе мобильных устройств, которая фиксирует курьеров на их маршрутах и повышает эффективность за счет мониторинга активности курьеров, их отсутствия на работе и производительности труда."*
Тут можно выделить ряд характерных признаков, которые будут указывать, что это требования от бизнеса:
* бизнес-требования всегда написаны с точки зрения клиента;
* это широкие требования высокого уровня, но все же ориентированные на детали;
* они не являются целями компании, но помогают компании достичь целей;
* отвечают на вопросы «**почему**» и «**что**». Что хочет компания получить? И почему ей это нужно.
Функциональные требования — это *Действия*, которые система должна выполнить, для реализации бизнес-требований. Таким образом, функциональные требования связаны с разрабатываемым решением или программным обеспечением. Сформулируем функциональные требования для вышеуказанного примера:
* система должна отображать долготу и широту сотрудника через GPS/ГЛОНАСС;
* система должна отображать позиции сотрудников на карте;
* система должна позволять менеджерам отправлять уведомления своим подчиненным на местах.
Выделим следующие особенности:
* функциональные требования всегда пишутся с точки зрения системы;
* они более конкретные и подробные;
* именно благодаря выполнению функциональных требований, разрабатывается, эффективное решение, отвечающее потребностям бизнеса и целям клиента;
* отвечают на вопрос «**как**». Как система решает бизнес требования.
Следует сказать пару слов о нефункциональных требованиях (также известных как «требования к качеству»), которые накладывают ограничения на дизайн или реализацию (например, требования к производительности, безопасности, доступности, надежности). Такие требования отвечают на вопрос «**какой**» должна быть система.
Разработка — это перевод бизнес требований в функциональные. Прикладное программирование — это реализация функциональных требований, а системное — нефункциональных.
Варианты использования (Use cases)
==================================
Реализация функциональных требований является, зачастую, самой сложной в коммерческих системах. В [чистой архитектуре](https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure-ebook/dp/B075LRM681) функциональные требования реализуются через слой *Use Case*.
Но для начала, я хочу обратится к первоисточнику. Ивар Якобсон — автор определения *Use Case*, один из авторов UML, и методологии RUP, в своей статье [Use-Case 2.0 The Hub of Software Development](https://www.ivarjacobson.com/sites/default/files/field_iji_file/article/use-case_2.0_final_rev3.pdf) выделяет 6 принципов применения *Вариантов использования*:
1. сделайте их простыми через повествование;
2. имейте стратегический план, осознайте картину целиком;
3. сфокусируйтесь на значении;
4. выстраивайте систему по слоям;
5. поставляйте систему пошагово;
6. удовлетворяйте потребности команды.
Кратко рассмотрим каждый из этих принципов, нам они пригодятся для дальнейшего понимания. Ниже идет мой вольный перевод, с сокращениями и вставками, настоятельно рекомендую ознакомиться и с оригиналом.
### Простота через повествование
*Повествование — часть нашей культуры; это самый простой и эффективный способ передачи знаний, информации одного человека — другому. Это лучший способ сообщить о том, что должна делать система, и помочь команде сосредоточиться на общих целях.*
*Варианты использования отражают цели системы. Чтобы понять Вариант Использования, мы рассказываем, повествуем некую историю. История рассказывает о том, как достичь цели и как решить проблемы, возникающие на пути. Варианты использования, как сборник рассказов, предоставляют способ идентифицировать и охватить все разные, но связанные истории простым, всеобъемлющим способом. Это позволяет легко собирать, распространять и понимать требования системы.*
Данный принцип коррелирует с партерном [Общий язык](http://habr.com/ru/post/428209/#edinyy-yazyk) (Ubiques language) из DDD подхода.
### Понимание картины в целом
*Независимо от того, какую систему вы разрабатываете, большую, маленькую, программную, аппаратную или бизнес-систему, понимание общей картины очень важно. Без понимания системы в целом вы не сможете принимать правильные решения о том, что включать в систему, что исключать, сколько это будет стоить и какую пользу это принесет.*
Ивар Якобсон предлагает задействовать [диаграмму вариантов использования](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%BF%D1%80%D0%B5%D1%86%D0%B5%D0%B4%D0%B5%D0%BD%D1%82%D0%BE%D0%B2), что очень удобно для сбора требований. Если требования собраны и ясны, то лучшим вариантом будет [Контекстная карта](https://habr.com/ru/post/428209/#ogranichennyy-konteksty-i-domeny) (Context map) Эрика Эванса. Зачастую, Scrum подход интерпретируют так, что люди не тратят время на стратегический план, считая планирование, дальше чем на две недели, пережитком прошлого. Пропаганда Джеффа Сазерленда обрушилась на waterflow, а люди закончившие двухнедельные курсы подготовки скрам-мастеров, допущенные к управлению проектами, сделали свое дело. Но здравый смысл, осознает важность стратегического планирования. Не нужно делать детальный стратегический план, но он должен быть.
### Фокус на значении
*Пытаясь понять, как будет использоваться система, всегда важно сосредоточиться на ценности, которую она предоставит своим пользователям и другим заинтересованным сторонам. Ценность формируется только в том случае, когда система используется. Поэтому гораздо лучше сосредоточиться на том, как система будет применяться, чем на длинных списках функций или возможностей, которые она может предложить.*
*Варианты использования обеспечивают этот фокус, помогая вам сконцентрироваться на том, как система будет задействована конкретным пользователем для достижения его цели. Варианты использования охватывают множество способов применения системы: те, которые успешно достигают целей, и те, которые решают любые возникающие сложности.*
Далее автор приводит замечательную схему, на которую следует обратить самое пристальное внимание:
На схеме показан вариант использования, «Снятие наличных в банкомате». Самый простой способ достижения цели описывается в *Основном Направлении* (Basic flow). Другие случаи описываются как *Альтернативные Направления* (alternative flow). Эти направления помогают с повествованием, структурируют систему и помогают с написанием тестов.
### Послойное построение
*Большинство систем требуют большой работы, прежде чем они будут готовы к использованию. У них много требований, большинство из которых зависят от других требований, они должны быть реализованы, прежде чем требования будут выполнены и оценены.*
*Большая ошибка создать такую систему за раз за один раз. Система должна быть построена из кусочков, каждый из которых имеет четкую ценность для пользователей.*
Эти идеи перекликаются с подходами гибкой разработки и с идеями *Доменов* (Domain).
### Пошаговый вывод продукта на рынок
*Большинство программных систем развиваются на протяжении многих поколений. Они не производятся за один раз; они построены в виде серии выпусков, каждое из которых построена на предыдущем выпуске. Даже сами релизы часто не выходят за раз, а развиваются через серию промежуточных версий. Каждый шаг предоставляет наглядную, пригодную для использования версию системы. Это тот способ, которым должны быть созданы все системы.*
### Удовлетворять потребности команды
*К сожалению, не существует универсального решения проблем разработки программного обеспечения; разные команды и разные ситуации требуют разных стилей и разных уровней детализации. Независимо от того, какие методы и приемы вы выберете, вы должны убедиться, что они достаточно адаптируемые для удовлетворения текущих потребностей команды.*
Эрик Эванс в своей книге призывает не тратить много времени на описания всех процессов через UML. Достаточно использовать любые наглядные схемы. Разным командам, разным проектам требуется разная степень детализации, об это говорит и сам автор UML.
Реализация
==========
В чистой архитектуре Робертом Мартином дается следующее определение *Вариантов использования* :
> These use cases orchestrate the flow of data to and from the entities, and direct those entities to use their Critical Business Rules to achieve the goals of the use case.
Попробуем воплотить эти идеи в код. Давайте вспомним схему из третьего принципа применения *Вариантов использования* и возьмем ее за основу. Рассмотрим действительно сложный бизнес-процесс: «Приготовление пирога с капустой».
Давайте попробуем его декомпозировать:
* проверить наличие продуктов;
* взять их со склада;
* замесить тесто;
* дать тесту подняться;
* подготовить начинку;
* сделать пирог;
* испечь пирог.
Всю эту последовательность мы реализуем через *Интерактор* (Interactor), а каждый шаг будет реализован через функцию или *Функциональный объект* (Functional Object) на *Сервисном слое* (Service Layer).
Последовательность действий (Interactor)
========================================
Я очень рекомендую начинать разработку сложного бизнес-процесса именно с *Последовательности действий*. Точнее не так, вы должны определить *Доменную область*, к которой относится бизнес-процесс. Уточнить все требования бизнеса. Определить все [*Сущности*](http://habr.com/ru/post/435920/#suschnost-entity), которые задействованы в процессе. Задокументировать требования и определения каждой *Сущности* в базе знаний.
Расписать все на бумаге по шагам. Иногда потребуется [Диаграмма последовательности](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8) (sequence diagram). Ее автор тот же, кто придумал *Варианты использования* (Use Case) — Ивар Якобсон. Диаграмма была придумана им, когда он разрабатывал систему обслуживания телефонных сетей для компании Эриксон, взяв за основу схему реле. Мне очень нравится эта диаграмма, и термин *Sequence*, на мой взгляд более выразителен, чем термин *Interactor*. Но ввиду большей распространенности последнего, будем использовать привычный термин — *Interactor*.
Небольшая подсказка, когда вы описывайте бизнес-процесс хорошим подспорьем для вас, может стать, основное правило документооборота: «В результате любой хозяйственной деятельности, должен быть составлен документ». К примеру, мы разрабатываем систему скидок. Предоставляя скидку, мы по факту, с точки зрения бизнеса, заключаем договор между компанией и клиентом. В этом договоре должны быть прописаны все условия. То есть в домене DiscountSystem, у вас будет Entites::Contract. Не привязывайте скидку к клиенту, а создайте *Сущность* Контракт, где описываются правила ее предоставления.
Вернемся к описанию нашего бизнес-процесса, после того, как он стал прозрачен для всех лиц задействованных в его разработке, и все ваши знания зафиксированы. Я рекомендую начать написание кода именно с *Последовательности действий*.
Шаблон проектирования *Последовательности действий* отвечает за:
* последовательность выполнения *Действий*;
* координацию передаваемых данных между *Действиями*;
* обработку ошибок совершаемых *Действиями* во время их выполнения;
* возвращение результата совокупности совершенных *Действий*;
* **ВАЖНО**: самая главная ответственность этого шаблона проектирования — реализация бизнес логики.
На последней ответственности хотелось бы остановиться подробнее, если у нас имеется какой-то сложный процесс — мы должны описать его так, чтобы было понятно, что происходит не вдаваясь в технические детали. **Вы должны описать его настолько выразительно, насколько это позволяет вам ваши навыки программирования**. Доверьте этот класс самому опытному члену вашей команды.
Вернемся к пирогу: попробуем описать процесс его приготовления через *Interactor*.
Реализация
----------
Привожу пример реализации, с нашим решением [LunaPark](https://lunapark.dev/#/), которое мы представили в предыдущей статье.
```
module Kitchen
module Sequences
class CookingPieWithСabbage < LunaPark::Interactors::Sequence
TEMPERATURE = Values::Temperature.new(180, unit: :cel)
def call!
Services::CheckProductsAvailability.call list: ingredients
dough = Services::BeatDough.call from: Repository::Products.get(beat_ingredients)
filler = Services::MakeСabbageFiller.call from: Repository::Products.get(filler_ingredients)
pie = Services::MakePie.call dough, with: filler
bake = Services::BakePie.new pie, temp: TEMPERATURE
sleep 5.min until bake.call
pie
end
private
attr_accessor :beat_ingredients, :filler_ingredients
attr_accessor :pie
def ingredients_list
beat_ingredients_list + filler_ingredients_list
end
end
end
end
```
Как мы видим, метод `call!` описывает всю бизнес-логику процесса выпечки пирога. И его удобно использовать для понимания логики приложения.
Также, мы легко можем описать процесс выпечки рыбного пирога, заменив `MakeСabbageFiller` на `MakeFishFiller`. Тем самым, мы очень быстро меняем бизнес-процесс, без существенных доработок кода. И также, мы можем оставить обе *Последовательности* одновременно, масштабируя бизнес-кейсы.
### Договоренности
* Метод `call!` является обязательным методом, он описывает порядок *Действий*.
* Каждый параметр инициализации может описываться через сеттер или `attr_acessor`:
```
class Foo < LunaPark::Interactors::Sequence
# ...
private
attr_accessor :bar
end
Foo.call(bar: 42)
```
* Остальные методы должны быть приватными.
Пример использования
--------------------
```
beat_ingredients = [
Entity::Product.new :flour, 500, :gr,
Entity::Product.new :oil, 50, :gr,
Entity::Product.new :salt, 1, :spoon,
Entity::Product.new :milk, 150, :ml,
Entity::Product.new :egg, 1, :unit,
Entity::Product.new :yeast, 1, :spoon
]
filler_ingredients = [
Entity::Product.new :cabbage, 500, :gr,
Entity::Product.new :salt, 1, :spoon,
Entity::Product.new :pepper, 1, :spoon
]
cooking = CookingPieWithСabbage.call(
beat_ingredients: beat_ingredients,
filler_ingredients: filler_ingredients
)
# В случае успеха:
cooking.success? # => true
cooking.fail # => false
cooking.fail_message # => ''
cooking.data # => Entity::Pie
# Если пирог сгорел:
cooking.success? # => false
cooking.fail # => true
cooking.fail_message # => 'The pie burned out'
cooking.data # => nil
```
Процесс представлен через объект и мы имеем все необходимые методы для его вызова — прошел ли вызов успешно, возникла ли какая-то ошибка в процессе вызова, и если произошла, то какая?
Обработка ошибок
----------------
Если сейчас вспомнить третий принцип применения Use Case, обратим внимание на то, что кроме *Основного направления*, у нас были еще и *Альтернативные* направления. Это ошибки, которые мы должны обработать. Рассмотрим пример: мы конечно не хотим чтобы события пошли подобным образом, но ничего не можем с этим поделать, суровая реальность такова, что пироги периодически сгорают.
*Interactor* перехватывает все ошибки унаследованные от класса `LunaPark::Errors::Processing`.
Как нам уследить за пирогом? Для этого определим ошибку `Burned` в *Действие* `BakePie`.
```
module Kitchen
module Errors
class Burned < LunaPark::Errors::Processing; end
end
end
```
И во время выпечки, проверим, что наш пирог не сгорел:
```
module Kitchen
module Services
class BakePie < LunaPark::Callable
def call
# ...
rescue Errors::Burned, 'The pie burned out' if pie.burned?
# ...
end
end
end
end
```
В этом случае сработает перехватчик ошибок, и мы сможем разобраться с ними в `Эндпоинтах`.
Ошибки, не унаследованные от `Processing`, воспринимаются как системные и будут перехвачены на уровне сервера. Если не обозначенные другие условия, то пользователь получит 500 ServerError.
Практика использования
----------------------
### 1. Старайтесь описывать все вызовы в методе call!
Не следует реализовывать каждое *Действие* отдельным методом, это делает код более раздутым. Приходится просматривать весь класс несколько раз, чтобы понять как он работает. Испортим рецепт выпечки пирога:
```
module Service
class CookingPieWithСabbage < LunaPark::Interactors::Sequence
def call!
check_products_availability
make_cabbage_filler
make_pie
bake
end
private
def check_products_availability
Services::CheckProductsAvailability.call list: ingredients
end
# ...
end
end
```
Используйте вызов действий прямо в классе. Такой подход с точки зрения ruby может показаться непривычным, так он выглядит более читабельным:
```
class DrivingStart < LunaPark::Interactors::Sequence
def call!
Service::CheckEngine.call
Service::StartUpTheIgnition.call car, with: key
Service::ChangeGear.call car.gear_box, to: :drive
Service::StepOnTheGas.call car.pedals[:right]
end
end
```
### 2. По возможности используйте метод класса call
```
# good - Обычно, экземпляр класса Действия, редко используется.
# Логично использовать сокращенную запись.
Sequence::RingingToPerson.call(params)
# good - Тем не менее, есть возможность создавать экземпляр объекта Действиe,
# что может быть полезно, когда нам нужно переиспользовать его,
# с учетом внутреннего состояния.
ring = Sequence::RingingToPerson.new(person)
unless ring.success?
ring.call
sleep 5.min
end
```
### 3. Не создавайте *Функциональные объекты* ради типизации кода, смотрите по ситуации
```
# bad - мы решили делать всю логику в Функциональных объектах, чтобы
# сделать более легкой Последовательность действий.
module Services
class BuildUser < LunaPark::Callable
def initialize(first_name:, last_name:, phone:)
@first_name = first_name
@last_name = last_name
@phone = phone
end
def call
Entity::User.new(
first_name: first_name,
last_name: last_name,
phone: phone
)
end
private
attr_reader :first_name, :last_name, :phone
end
end
module Sequences
class RegisteringUser < LunaPark::Interactors::Sequence
attr_accessor :first_name, :last_name, :phone
def call!
user = Service::BuildUser.call(first_name: first_name, last_name: last_name, phone: phone)
end
end
end
# good - не следует писать отдельный класс, действуем практичнее.
# Хотя при такой реализации следует задуматься о тестировании,
# возможно необходимо вынести метод в Сервисный слой.
module Sequences
class RegisteringUser < LunaPark::Interactors::Sequence
attr_accessor :first_name, :last_name, :phone
def call!
user #...
end
private
def user
@user = Entity::User.new(
first_name: first_name,
last_name: last_name,
phone: phone
)
end
end
end
```
Сервисный слой (Service Layer)
==============================
*Порядок действий* (Interactor), как мы говорили, описывает бизнес-логику на самом верхнем уровне. *Сервисный слой* (Service layer) уже раскрывает детали реализации функциональных требований. Если мы говорим о приготовлении пирога, то на уровне *Порядка действий* (Interactor) мы говорим просто "замешиваем тесто", не вдаваясь в детали как его замесить. Процесс замеса описывается на *Сервисном уровне*. Вернемся к первоисточнику, [большой синей книге](https://www.oreilly.com/library/view/domain-driven-design-tackling/0321125215/):
*В прикладной предметной области бывают такие операции, которым нельзя найти естественное место в объекте типа Сущности (Entity) или Объекта-Значения (Value object). Они по своей сути являются не предметами, а видами деятельности. Но поскольку в основе нашей парадигмы моделирования лежит объектный подход, мы попробуем превратить их в объекты.*
*В этом месте легко совершить распространенную ошибку: отказаться от попытки поместить операцию в подходящий для нее объект, и таким образом, прийти к процедурному программированию. Но если насильно поместить операцию в объект с чуждым ей определением, от этого сам объект утратит чистоту замысла, станет труднее для понимания и рефакторинга. Если в простом объекте реализовать много сложных операций, он может превратиться в непонятно что, занятое непонятно чем. В таких операциях часто участвуют другие объекты предметной области и между ними выполняется согласование для выполнения совместной задачи. Дополнительная ответственность создает цепочки зависимости между объектами, смешивая понятия, которые можно было бы рассматривать независимо.*
При выборе места реализации того или иного функционала, всегда пользуйтесь здравым смыслом. Ваша задача — сделать модель более выразительной. Разберем пример, "Нам нужно нарубить дрова" :
```
module Entities
class Wood
def chop
# ...
end
end
end
```
Такой метод будет являться ошибкой. Дрова сами себя не нарубят, нам потребуется топор:
```
module Entities
class Axe
def chop(sacrifice)
# ...
end
end
end
```
Если мы используем упрощенную бизнес-модель, этого будет достаточно. Но если процесс нужно смоделировать более детально, нам понадобится человек, который будет рубить эти дрова, и возможно, некоторое бревно, которое будет использоваться в качестве подставки для осуществления процесса.
```
module Entities
class Human
def chop_firewood(wood, axe, chock)
# ...
end
end
end
```
Как вы уже наверное догадались, это не самая удачная идея. Не все из нас занимаются рубкой дров, это не прямая обязанность человека. Мы часто видим насколько перегружены модели в Ruby on Rails, хранящие в себе подобную логику: получение скидки, добавление товара в корзину, снятие денег к балансу. Эта логика относится не к сущности, а к процессу в котором задействована эта сущность.
```
module Services
class ChopFirewood
# ...
end
end
```
После того, как мы разобрались, какую логику мы храним в *Службах* попробуем реализовать один из них. Чаще всего службы реализуются через методы или функциональные объекты.
Функциональные объекты
----------------------
Функциональный объект выполняет одно функциональное требование. В самом примитивном виде функциональный объект имеет один единственный публичный метод — `call`.
```
module Serivices
class Sum
def initialize(x, y)
@x = x
@y = y
end
def call
x + y
end
def self.call(x,y)
new(x,y).call
end
private
attr_reader :x, :y
end
end
```
Такие объекты имеют ряд преимуществ: они лаконичны, их очень просто тестировать. Есть и недостаток, таких объектов может получиться большое количество. Есть несколько способов сгруппировать подобные объекты, мы в части своих проектов делим их по типу:
* *Сервисный объект* (Service) — объект, создает новый объект;
* *Команда* (Command) — изменяет текущий объект;
* *Вахтер* (Guard) — возвращает ошибку если, что-то пошло не так.
Сервисный Объект (Service)
--------------------------
В нашей реализации *Service* — реализует функциональное требование и всегда возвращает значение.
```
module KorovaMilkBar
module Services
class FindMilk < LunaPark::Callable
GLASS_SIZE = Values::Unit.wrap '200g'
def initialize(fridge:)
@fridge = fridge
end
def call
fridge.shelfs.find { |shelf| shelf.has?(GLASS_SIZE, of: :milk) }
end
private
attr_reader :fridge
end
end
end
FindMilk.call(fridge: the_red_one) # => #
```
Команда (Command)
-----------------
В нашей реализации *Command* — выполняет одно *Действие*, изменяет объект, в случае успеха возвращает true. По факту, *Команда* не создает объект, а изменяет существующий.
```
module KorovaMilkBar
module Commands
class FillGlass < LunaPark::Callable
def initialize(glass, with:)
@glass = glass
@content = with
end
def call
glass << content
true
end
private
attr_reader :fridge
end
end
end
glass = Glass.empty
milk = Milk.new(200, :gr)
glass.empty? # => true
FillGlass.call glass, with: milk # => true
glass.empty? # => false
```
Вахтер (Guard)
--------------
*Вахтер*, выполняет логическую проверку и в случае провала выдает ошибку обработки. Такой тип объекта никак не влияет на *Основное направление*, но переключает нас на *Альтернативное направление*, если что-то пошло не так.
При подаче молока важно убедится, что оно свежее:
```
module KorovaMilkBar
module Guards
class IsFresh < LunaPark::Callable
def initialize(product)
@products = products
end
def call
products.each do |product|
raise Errors::Rotten, "#{product.title} is not fresh" if product.expiration_date > Date.today
end
nil
end
private
attr_reader :products
end
end
end
```
Возможно вам покажется удобным разделять функциональные объекты по типу. Вы можете добавить свои, например, *Builder* — создает объект на основе параметров.
### Договоренности
* Метод `call` является единственным обязательным публичным методом.
* Метод `initialize` является единственным опциональным публичным методом.
* Остальные методы должны быть приватными.
* Логические ошибки должны наследоваться от класса `LunaPark::Errors::Processing` .
Обработка ошибок
----------------
Следует разделить 2 типа ошибок, которые могут произойти во время работы того или иного *Действия*.
##### Ошибки процесса выполнения
Такие ошибки могут возникать в результате нарушения логики обработки.
Например:
* при создании пользователя email зарезервирован;
* при попытке выпить молоко, оно закончилось;
* другой микросервис отклонил действие (по логической причине, а не потому, что сервис недоступен).
По всей вероятности, об этих ошибках захочет узнать пользователь. Также, вероятно, это те ошибки,
которые мы можем предвидеть.
Такие ошибки должны наследоваться от `LunaPark::Errors::Processing`
##### Системный ошибки
Ошибки, которые произошли в результате сбоя системы.
Например:
* не работает БД;
* что-то поделилось на ноль.
По всей вероятности, мы не можем предвидеть эти ошибки и ничего не можем сказать пользователю, кроме того, что все очень плохо, и отправить разработчикам отчет, призывающий к действию. Такие ошибки должны наследоваться от `SystemError`
Есть еще, **ошибки валидации**, которые мы рассмотрим подробнее в следующей статье.
Практика использования
----------------------
### 1. Используйте переменные, чтобы повысить читаемость
```
module Fishing
# bad - не информативно
Serivices::Catch.call(fish, rod)
# bad - избыточно
Serivices::Catch.call(fish: fish, rod: rod)
# good - более выразительно
Serivices::Catch.call(fish, with: rod)
module Serivices
class Catch
def initialize(fish, with:)
@fish = fish
@rod = with # внутри класса мы используем переменную
# указывающую на объект.
end
# ...
private
attr_reader :fish, :rod
end
end
end
```
### 2. Передавайте объекты, а не параметры
Старайтесь делать инициализатор простым, если обработка параметров не является его целью.
Передавайте объекты, а не параметры.
```
module Service
# bad - на сервисном уровне мы работаем только с бизнес-логикой. Преобразование
# типов следует вынести на уровень выше, например в форму.
class Foo
def initialize(foo_params:, bar_params:)
@foo = Values::Foo.new(*foo_params)
@bar = Values::Bar.new(*bar_params)
end
# ...
end
Services::Foo.call(foo: {a: 1, b: 2}, bar: 34)
# good - реализуем только бизнес-логику.
class Bar
def initialize(foo:, bar:)
@foo = foo
@bar = bar
# ...
end
end
foo = Values::Foo.new(a: 1, b: 2)
bar = Values::Bar.new(34)
Services::Bar.call(foo: foo, bar: bar)
# good - логичным исключением является реализация шаблона проектирования - Builder.
class BuildFoo
def initialize(param_1:, param_2:)
@param_1 = param_1
@param_1 = param_1
end
def call
Foo.new(
param_1: param_1.foo,
param_2: param_2.bar,
param_3: some_magick
)
end
# ...
end
end
```
### 3. Используйте в название Действия — глагол действия и объект воздействия.
```
# bad
module Services
class Milk; end
class Work; end
class FooBuild; end
class PasswordGenerator; end
end
# good
module Services
class GetMilk; end
class WorkOnTable; end
class BuildFoo; end
class GeneratePassword; end
end
```
### 4. По возможности используйте метод класса call
Обычно экземпляр класса *Действия*, редко используется кроме того, чтобы писать сделать вызов.
```
# good - Логично использовать сокращенную запись.
Services::BuildFoo.call(params)
# good - Или еще более сокращенную
Services::BuildFoo.(params)
# good - Тем не менее, есть возможность создавать экземпляр объекта Действия,
# что может быть полезно, когда нам нужно переиспользовать его, с учетом
# внутреннего состояния.
ring = Services::RingToPhone.new(phone: neighbour)
10.times do
ring.call
end
```
### 5. Обработка ошибок не является задачей сервиса
```
# bad - оставьте обработку ошибку интеракторам, а сервис легким.
def call
#...
rescue SystemError => e
return false
end
```
Модули
------
До этого момента мы рассматривали имплементацию *Сервисного слоя* как набора функциональных объектов. Но мы легко можем разместить на этом слое методы:
```
module Services
def sum(a, b)
a + b
end
end
```
Другая проблема, которая встает перед нами — большое количество сервисных объектов. Вместо, набивших оскомину «rails fat model», мы получим «services fat folder». Есть несколько способов организовать структуру, чтобы уменьшить масштаб трагедии. Эрик Эванс решает это за счет того, что объединяет ряд функций в один класс. Представим, что нам нужно смоделировать бизнес-процессы няни, Арины Родионовны, она может кормить Пушкина и укладывать его спать:
```
class NoonService
def initialize(arina_radionovna, pushkin)
# ...
end
def to_feed
# ...
end
def to_sleep
# ...
end
end
```
Такой подход более корректный с точки зрения ООП. Но мы предлагаем от него отказаться, по крайней мере, на начальных этапах. Не очень опытные программисты начинают писать много кода в таком классе, что в конечном счете приводит к увеличению связности. Вместо этого можно использовать модуль, представляя деятельность некоторой абстракцией:
```
module Services
module Noon
class ToFeed
def call!
# ...
end
end
class << self
# При этом сложные процессы, можно вынести
# в функциональные объекты
def to_feed(arina_radionovna, pushkin)
ToFeed.new(arina_radionovna, pushkin).call
end
# А простые оставить методами, реализованными в модуле
def to_sleep(arina_radionovna, pushkin)
arina_radionovna.tell_story pushkin
pushkin.state = :sleep
end
end
end
end
```
При делении на модули должна соблюдаться низкая внешняя зависимость (low coupling) при высокой внутренней связности (high cohesion), мы же используем такие модули как Services, или Interactors, это также идет в разрез с идеями чистой архитектуры. Это осознанный выбор, который облегчает восприятие. По имени файла мы понимаем какой шаблон проектирования реализует тот или иной класс, если для опытного программиста это очевидно, то для новичка это не всегда так. После того как ваша команда будет готова, откажитесь от этого излишества.
Процитирую еще небольшой отрывок из большой синей книги:
*Выберите такие модули, которые бы рассказывали историю системы и содержали связные наборы понятий. От этого часто сама собой возникает низкая зависимость модулей друг от друга. Но если это не так, найдите способ изменить модель таким образом, чтобы отделить понятия друг от друга, или же поищите пропущенное в модели понятие, которое могло бы стать основой для модуля и тем самым свести элементы модели вместе естественным, осмысленным способом. Добивайтесь низкой зависимости модулей друг от друга в том смысле, чтобы понятия в разных модулях можно было анализировать и воспринимать независимо друг от друга. Доработайте модель до тех пор, пока в ней не возникнут естественные границы в соответствии с высокоуровневыми концепциями предметной области, а соответствующий код не разделится соответствующим образом.*
*Дайте модулям такие имена, которые войдут в ЕДИНЫЙ ЯЗЫК. Как сами МОДУЛИ, так и их имена должны отражать знание и понимание предметной области.*
Тема модулей большая и интересная, но в полном объеме явно выходит за тему данной статьи. В следующий раз мы поговорим с вами о *Репозиториях* и *Адаптерах*. Мы открыли [уютный телеграмм канал](https://t.me/lunapark_dev), где хотелось бы делиться материалами на тему DDD. Будем рады вашим вопросам и обратной связи.
---
**Источники вдохновения*** <https://www.netsolutions.com/insights/business-and-functional-requirements-what-is-the-difference-and-why-should-you-care/>
* <http://magazines.russ.ru/nz/2007/54/gi3.html>
* <https://www.microtool.de/en/knowledge-base/how-use-case-2-0-works/>
* <https://www.researchgate.net/publication/220059381_Use_cases_-_Yesterday_today_and_tomorrow>
* Проблемно-ориентированное проектирование, Эрик Дж. Эванс | https://habr.com/ru/post/454668/ | null | ru | null |
# Как мы превратили задание для найма тестировщиков в интерактив для конференции и читателей «Хабра»
Месяц назад мы приняли участие в конференции [SQA Days](https://sqadays.com/ru/index). Наши эксперты выступили с докладом (вот [презентация](https://sqadays.com/ru/talk/87626), ждите подробную статью и видео выступления) и провели ряд активностей на стенде. Сегодня мы хотим рассказать об одной из них – и интересна она тем, что по факту это задание, которое в «AliExpress Россия» используется на собеседования тестировщиков.
В этом материале мы расскажем о предыстории появления тестового задания, его эволюции и дадим возможность всем желающим проверить свои силы в поисках багов.
Предыстория
-----------
Раньше на собеседованиях со специалистами по тестированию в компании давали соискателям тестовое задание на поиск багов. Интересный факт заключался в том, что оно было теоретическим – то есть никакой реальной системы человек не получал, мы просто ее описывали на словах и предлагали порассуждать о том, как можно искать в ней баги.
Шли месяцы, и в какой-то момент мы подумали, что наглядность в такого рода задачах – это хорошо, и решили визуализировать наш тест. Выглядело все это так: мы создали простой эндпоинт, который принимал Post-запросы и отдавал ответы.
Простая программа принимала данные на вход и сообщала пользователю, введено число или нет. В этом «софте» из пары строк кода на Java + SpringBoot и нужно было искать баги.
```
@RestController
@SpringBootApplication
@Slf4j
public class IsNumberApplication {
public static void main(String[] args) {
SpringApplication.run(IsNumberApplication.class, args);
}
@PostMapping(path = "/isnumber", consumes = "application/json", produces = "application/json")
public IsNumberResponse hello(@RequestBody IsNumberRequest request) {
String requestValue = request.value;
log.info("Request value is '{}'", requestValue);
boolean isNumber;
try {
Float.parseFloat(requestValue);
isNumber = true;
} catch (NumberFormatException e) {
isNumber = requestValue.equals(Boolean.toString(true));
}
return new IsNumberResponse(isNumber);
}
}
```
Причем тесты можно было попробовать автоматизировать – в качестве домашнего задания мы предлагали кандидатам написать автотесты на данный API.
Вот простенький пример теста на Java + Junit5 + RestAssured:
```
@Test
void positiveNumber() {
RestAssured.with().contentType(ContentType.JSON)
.body(new IsNumberBody(5))
.post("/isnumber")
.then()
.statusCode(OK)
.body("isNumber", equalTo(true));
}
```
Такой подход и «открытое» задание без особенных ограничений позволяют хорошо раскрыть специалиста. Кто-то проверяет только очевидные моменты, а кто-то в своих исследованиях даже по такой простой фиче пытается докопаться до самых мелких деталей. В итоге именно это и подвигло нас доделать движок теста, реализовать полноценный фронтенд и доработать существующий бэкенд.
Естественно, и во фронт-, и в бэк-части мы намеренно заложили ряд багов, которые и нужно было обнаружить.
Тестовое задание и активность на конференции
--------------------------------------------
Когда мы решили принять участие в конференции SQA Days, то встал вопрос, что мы там будем делать, помимо доклада. И тут пришла идея использовать наше тестовое задание в качестве одной из активностей на стенде. Тем, кто выполнил его, мы хотели дарить призовые купоны, которые можно потратить на AliExpress.
Конечно, для того чтобы превратить тестовое задание для проверки соискателей вакансий в интересную стендовую активность, требовались доработки. Мы решили, что проверяемая функция должна быть доступна внутри приложения AliExpress, а работать она будет с нашим, уже готовым бэкендом. Подготовить всё в срок нам помог наш фронтенд-разработчик (спасибо, Инал!).
Ниже – кусок кода фронта с заложенными багами:
```
const SqaDaysPage = () => {
const [inputValue, setInputValue] = useState('');
const [isShowAgain, setIsShowAgain] = useState(true);
const [isFirstCall, setIsFirstCall] = useState(true);
const {showModal, hideModal, activeModal} = useContext(ModalContext);
const onSendAnswer = async () => {
// Block request if it's the first call
if (isFirstCall) {
return setIsFirstCall(false);
}
setIsLoading(true);
universalFetch('https://api.aliexpress.ru/***/***', {
method: 'POST',
headers: {},
body: JSON.stringify({ value: inputValue }),
}).then((response) => response.json())
.then(({ error, isNumber }) => {
setIsLoading(false);
if (error)
// some code...
// Hardcode logic
if (Number(requestData.value) === 0)
isNumber = false;
return toast.show({
duration: 1500,
type: isNumber ? 'default' : 'error',
text: isNumber ? `Это число: ${inputValue}` : `Это не число: ${inputValue}`,
});
})
.catch(() => {
// some code...
});
};
const onCloseWelcomePopup = () => {
hideModal();
// If true, show welcome popup again after 40 sec.
if (isShowAgain) {
setTimeout(() => {
showModal({ id: WELCOME_POPUP });
setIsShowAgain(false);
}, 40000);
}
};
return (
{/* some code... */}
Отправить
{/* Display welcome popup */}
{/\* Show broken image in a second times \*/}
Тестовый стенд от AliExpress
Ваша задача найти все баги на данной странице. Также на этой странице есть несколько пасхалок, за нахождение которых вы можете получить приятные призы.
Закрыть
{/* some code... */}
)
}
```
Тест появлялся внутри мобильного браузера или приложения AliExpress после сканирования специального кода.
QR-код для старта заданияВот так выглядел тестовый стенд AliExpressТак мы могли гарантировать, что заведомо неправильно работающую функцию увидят только посетители нашего стенда. Само собой задание содержало в себе ряд очевидных и более сложных багов. Из простого:
* первый раз при попытке отправить вводные данные ничего не происходило;
* после закрытия поп-апа с приветствием он через какое-то время появлялся снова – уже с битой иконкой.
Участники конкурса репортили баги и в процессе открывали подарочные купоны, а также ценные призы (рюкзаки, толстовки) за найденные пасхалки. В итоге за пару дней конференции мы получили несколько десятков багрепортов.
Попробуйте пройти наш тест и выиграйте купон на AliExpress
----------------------------------------------------------
Мы будем развивать и видоизменять наше тестовое задание и дальше. Поиск заложенных багов будет сложнее. А пока мы хотим предложить задание в его текущем виде аудитории «Хабра».
> Получить доступ к тесту можно по [этой ссылке](https://promotion.aliexpress.ru/wow/gcp/3jHCBhR72w?wx_navbar_hidden=true&wx_navbar_transparent=true&ignoreNavigationBar=true&wx_statusbar_hidden=true) или отсканировав QR-код из поста выше камерой в приложении AliExpress. Первые 290 участников, отправивших решенное задание, получат подарочный купон на 100 рублей, которые можно потратить внутри AliExpress.
>
>
ВАЖНО: в системе есть еще один «баг»: купоны из мобильного браузера получить нельзя, испытание нужно проходить в приложении AliExpress.
\*\*\*
На сегодня всё, спасибо за внимание! В следующих постах мы расскажем о локализации мобильного приложения «AliExpress Россия», работах по исправлению багов и развитию инфраструктуры. | https://habr.com/ru/post/559126/ | null | ru | null |
# Cicada 3301: кого и куда должны были отобрать загадки таинственной «Цикады»? Часть 1
[](https://habr.com/ru/company/ruvds/blog/714806/)
Рассуждая о крипоте в [прошлой статье](http://habr.com/ru/company/ruvds/blog/713396/), мы коснулись темы одного из важнейших механизмов человеческого страха: неизвестности. Пугающая крипота нулевых перестала пугать потому, что превратилась во что-то хорошо известное, понятное и даже популярное. Точно так же рассказы Лавкрафта, мимикрировавшие подобно крипипасте под воспоминания, письма, дневниковые записи и рассказы очевидцев — куда лучше пугали до того, как его имя стало культовым, а его персонажи, начиная с Ктулху — любимейшими героями интернет-фольклора, мемов и даже персонажами детских книжек.
Однако целый ряд появлявшихся в сети феноменов, пусть и не всегда пугающих на уровне ранних крипипаст, до сих пор остаются неразгаданными. Кто и что делал с аккаунтом Webdriver Torso на YouTube, заполняя его сотнями тысяч видеороликов, и что из себя представляют найденные на том же видеохостинге аккаунты семейства «Unfavorable Semicircle»? Кто забрасывал Usenet странными сообщениями с заголовками Markovian Parallax Denigrate? Кем была записана «Самая загадочная песня в Интернете», видимо, в ФРГ начала 80-х? Кем был Чумной Доктор с видеозаписи 11B-X-1371, сочетавшей фотографии трупов с мест преступлений и фильмов ужасов с закодированными сообщениями? Была ли загадка от пользователя Publius Enigma о некоем закодированном послании в альбоме Pink Floyd «The Division Bell» 1994 года шуткой или чем-то большим?
Впрочем, самой масштабной и странной из подобных историй, на мой взгляд, стоит назвать «Цикаду 3301».
Некое сообщество людей, обладавшее не только обширными познаниями в криптографии и мировой культуре, но и возможностями размещать физические объекты сразу во множестве стран мира (дюжина городов США от Майами до Сиэтла и Гавайев, Париж, Москва, Варшава, Сеул, японская Окинава, испанская Гранада и далёкий австралийский Сидней) в январе 2012 года разместило на форчане (где ж ещё?) затравку для целого лабиринта кодов и загадок, которые должны были отобрать нескольких достойных, для некой цели.
Исходное сообщение в форме картинки с текстом гласило:
*«Привет! Мы ищем высокоинтеллектуальных людей. Чтобы найти их, мы разработали тест. В этом изображении скрыто сообщение. Найдите его, и оно приведёт вас на путь, ведущий к нам. Мы с нетерпением ждём встречи с теми немногими, кто пройдёт весь этот путь до конца. Удачи! 3301»*
Звучит как завязка одного из романов Дэна Брауна, которые в первой половине 2010-х воспринимались уже не столько как популярные хиты, сколько как предмет для сарказма. Однако всё это не было промо-акцией очередного голливудского блокбастера в жанре «таинственных поисков таинственных тайн» в окружении масонов, иллюминатов и прочих иезуитов, а происходило в реальности — и было продумано весьма детально, глубоко и даже элегантно.
Пожалуй, наиболее [подробный текст о дальнейшем](https://www.rollingstone.com/culture/culture-news/cicada-solving-the-webs-deepest-mystery-84394/) в январе 2015 года опубликовал американский журнал Rolling Stone. Журналистское расследование Дэвида Кушнера, популярного публициста и писателя (известного в том числе книгой «Потрачено. Беспредельная история GTA»), основано на информации, предоставленной Маркусом Уоннером и Текком — одними из тех, кто сумел быстрее всех разобраться в первой серии загадок «Цикады» и войти в круг посвящённых. Естественно, достоверность сведений в статье и количество умолчаний в ней остаются неизвестными.
*Обложка статьи Дэвида Кушнера в Rolling Stone «Cicada: Solving the Web’s Deepest Mystery» («Цикада: решение глубочайшей тайны Сети»)*
В начале 2012 года Маркус Уоннер (Marcus Wanner) был тощим 15-летним подростком из 100-тысячного Роанока в Вирджинии. Пятый ребёнок в многодетной семье хардкорных католиков перемещался в основном между школой, церковью и лагерем бойскаутов. Родители поначалу строго контролировали все его действия в сети, дабы невинное дитя не столкнулось ни с чем аморальным и бездуховным — что усугублялось тем, что его отец-инженер был технически грамотным. Маркус, обожавший компьютеры и айти, не имел права даже самовольно отправлять электронные письма или регистрироваться на интернет-ресурсах без дозволения родителей. А работать ему позволялось только за компьютером в гостиной, чтобы мать или отец могли видеть происходящее на экране.
Со временем демонстративно безупречное поведение отпрыска несколько успокоило старшее поколение… отчего младшее незамедлительно воспользовалось новообретённой свободой с ноутбуком для увлечённого зависания с битардами на Форчане.
Впрочем, зависал Маркус (по его словам) не столько на /b/, сколько в куда более почтенных разделах, посвящённых естествознанию и математике. Тем не менее, 7 января он забрёл на /x/ с крипотой и паранормальщиной, где и увидел то самое первое сообщение от 5 января 2012 года о поиске высокоинтеллектуальных людей посредством неких тестов.
Помимо компьютеров, Маркус увлекался загадками, ребусами, кодами и шифрами. Кубик Рубика он обычно собирал менее чем за минуту. Поначалу он решил, что это всего лишь очередная шутка над гиками и нёрдами от местных троллей. Однако ему было скучно, а тут как раз обнаружилось, что другие заинтересовавшиеся загадочным сообщением уже создали IRC-чат для обсуждения и попыток разобраться, что же это за «Цикада 3301».
Маркус двинулся в предложенную «Цикадой» «кроличью нору».
*Маркус Уоннер на момент написания статьи в 2015 году: в качестве подающего надежды студента второго курса возле суперкомпьютера Shadowfax Института биоинформатики Вирджинии. На тот момент Уоннер уже решил применить свой опыт в области криптографии и компьютерной безопасности для геномных исследований*
После некоторых колебаний — и представив, как он будет просить у консервативных католических родителей дозволения войти в чат с посетителями имиджборды, где едва ли не самым приличным мемом был каноничный портрет Чёрного Властелина — он впервые в жизни забил на требования старшего поколения и общался с единомышленниками безо всяческого разрешения.
В означенном чате Маркус встретил Текка — ещё одного увлечённого техногика и программиста, который после истории с «Цикадой» преисполнился некоторой паранойи и отказался давать колумнисту «Rolling Stone» какие бы то ни было данные о своей биографии даже при личной встрече. Известно лишь, что осенью 2014 года он уже был первокурсником одного из американских университетов. По словам автора статьи Дэвида Кушнера, Текк буквально подорвался от испуга, когда в пиццерии, где бралось интервью, кто-то уронил тарелку, и стал привычно оглядываться в поисках слежки.
Текк наткнулся на сообщение «Цикады» не сам — ну, по крайней мере, он так утверждает. По словам Текка, его ему показал знакомый из школьной лаборатории робототехники, который сидел на 4chan со школьного компьютера. Строго отчитав сверстника за нецелевое использование школьной матчасти, Текк стал искать ключ. Тот обнаружился при открытии файла изображения через WordPad: в полученном наборе символов обнаружился следующий фрагмент:
Текк уловил прямую отсылку к «шифру Цезаря», одной из старейших и простейших систем шифрования, подразумевающую простое смещение знаков алфавита на заданное количество символов. Подсказка к количеству символов содержалась в имени Тиберия Клавдия Цезаря. Император Клавдий, учёный и сенатор, провозглашённый правителем Римской империи после убийства доставшего всех Калигулы, был четвёртым на этой должности. Смещение на четыре знака дало Текку адрес веб-страницы `https://i.imgur.com/m9sYK.jpg`, при переходе на которую обнаружилось… изображение вот этой вот утки.
*«Например, кря»*
С пояснением, что это был ложный след — и дошедший до утки всё ещё не понял, как сделать следующий шаг в решении загадки «Цикады». В этот момент, пока Текк и другие пытались понять в IRC-чате, что делать с уткой и не является ли всё это просто шуткой, к участникам чата и присоединился Маркус. Поскольку в основном чате оказалось слишком много флуда и слишком мало дела, из него выделилась команда самых лютых энтузиастов из дюжины человек, включая Маркуса и Текка. Они создали свой чат с названием #decipher.
Самым, пожалуй, колоритным членом команды стал 26-летний саамский хакер, звуковик и дизайнер освещения Джон Хенрик Гутторм из глухого норвежского заполярья, который занялся кодом «Цикады» со скуки: по его словам, «мы тут на северах в основном ловим рыбу и занимаемся сексом, а зимой рыбы нет».
*С тех пор Джон Хенрик Гутторм успел спроектировать освещение для здания парламента норвежских саамов в Карасйок*
Пытаясь найти настоящую зацепку, члены чата #decipher перелопатили всю историю шифров и кодов, а также известные истории подобного рода из интернета: от рекламных кампаний фильмов Дэна Брауна, музыкальных альбомов и игр вроде The Dark Knight или Halo 2 и до практики британских и американских спецслужб искать себе сотрудников — в первую очередь криптографов — посредством публикации всевозможных загадок и шифров. Последнее придумал не кто иной, как Алан Тьюринг: в годы Второй мировой войны он отбирал кандидатов для работы над взломом немецких шифров, предлагая соискателям особо сложные кроссворды и задачи.
*«Криптос», монумент с зашифрованным посланием у штаб-квартиры ЦРУ в Лэнгли: на настоящий момент любителями криптографии разгаданы только три из четырёх секций кода*
Вспомнили и о том, как в 2004 году в калифорнийской Кремниевой долине и у Гарварда появилось объявление с предложением пройти по ссылке, которой являлось первое простое число из 10 цифр в последовательности знаков после запятой в константе *e*. Ссылка вела на последовательность криптографических задач, которые, в конце концов, приводили к предложению пройти собеседование на работу в Google Labs у соучредителя корпорации Сергея Брина.
Подсказка нашлась в картинке с уткой — текст про ложный след сам был одновременно ложным следом и подсказкой. Фраза looks like you can’t *GUESS* how to get the message *OUT*, «похоже, вы не можете догадаться, как извлечь это сообщение», отсылала к утилите OutGuess. Это стеганографическое ПО предназначалось для сокрытия данных в наиболее избыточных битах содержимого файлов, и в годы описываемых событий штатно включалось в репозитории программного обеспечения Linux Debian и Arch Linux.
Прогнав картинку с уткой через OutGuess, команда чата #decipher обнаружила новую подсказку. Перед ними появился набор из 75 сочетаний двух цифр через двоеточие и пояснение, что всё это является книжным кодом — ещё одним старинным методом шифрования, восходящим к XVI столетию и предполагающим получение нужных знаков через положение букв на страницах некой книги. Также к коду прилагалась ссылка, которая вела на страницу Реддита.
Там обнаружился целый сабреддит, раздел сайта, с заглавным графическим файлом и некоторое количество текстовых строк с явным шифром в виде хаотичного на первый взгляд набора букв и цифр.
Заглавный графический файл с именем `a2e7j6ic78h0j7eiejd0120` содержал строку из знаков в виде горизонтальных линий, точек и чего-то наподобие закрытой ракушки. Текк быстро опознал его как надпись на языке мезоамериканского народа майя. Нашлись ещё два изображения.
Одно, в виде дверного коврика с надписью Welcome, содержало вшитое пояснение о том, что с этого момента все подлинные сообщения от «Цикады 3301» будут подписываться PGP-ключом во избежание путаницы с подражателями. Через некоторое время это станет актуальным, так как у «Цикады» появятся подражатели, в том числе радикального толка.
Второе представляло собой случайно-точечную стереограмму из вышивок с изображением короля Артура, которые при изменении фокуса взгляда формировали стереоизображение стакана. Вшитое в файл послание через OutGuess сообщало, что «послание всегда находилось перед вашими глазами», и иронично добавляло, что «это не поиск святого Грааля, не переусложняйте». Затем шла контрольная PGP-сигнатура.
Расследователи обратились к заглавному изображению в виде знаков классического языка майя. А точнее — чисел: надпись представляла собой последовательность 10 2 14 7 19 6 18 12 7 8 17 0 19, которая соотносилась с названием файла `a2e7j6ic78h0j7eiejd0120`, и вместе они образовывали ключ `kcohtgsmhirathosotnabca` по методу полиалфавитного шифра Виженьера.
Этот ключ позволил преобразовать найденные в сабреддите строки в текст, который представлял собой фрагмент из книги «The Age of Fable» Томаса Булфинча, основанной на валлийских сказаниях Мабиногиона о похождениях рыцарей Круглого Стола (уточню, нет, это не было промо-ARG для очередной книги Дэна Брауна).
Правда, чтобы дойти до этой точки, Маркус, Текк, Гутторм и другие чуть не уехали крышей от психического напряжения, злости и недосыпа, а Гутторму от бессонных суток за мониторами среди полярной ночи пришлось даже потом лечить глаза.
Получив фрагмент книги, который служил, в свою очередь, ключом для книжного шифра, команда смогла наконец расшифровать последовательность из 75 пар цифр.
Сообщение содержало вполне банальную, но оттого лишь более таинственную фразу: call us at telephone number two one four three nine oh nine six oh eight. Сиречь «позвоните нам по телефонному номеру 214-390-9608».
В ответ на звонок на номер, судя по коду, зарегистрированный в техасском Далласе, записанный мужской голос произнёс: «Очень хорошо. Вы хорошо поработали. Есть три простых числа, связанных с оригинальным изображением `final.jpg`. 3301 — одно из них. Вам придётся найти два других. Перемножьте все три числа и добавьте *.com*, чтобы найти следующий шаг. Удачи. До свидания».
Этот ларчик открывался просто. Недостававшие два числа были зашифрованы в пиксельных размерах исходного графического файла, выложенного на Форчане: 509 на 503. Перемножение 509, 503 и 3301 дало число 845145127. Следовательно, нужно было отправиться по адресу `845145127.com`.
На сайте работал таймер и красовалось изображение цикады. Новое сообщение, найденное через OutGuess в картинке с цикадой, гласило: «Вы молодцы, что зашли так далеко. Терпение — это добродетель. Возвращайтесь в 17:00 в понедельник, 9 января 2012 года по UTC».
Ради того, чтобы увидеть послание в момент появления, Маркус вновь сломал все шаблоны: не отправился на собрание бойскаутов, чего раньше никогда не делал. Да и в целом его состояние из-за бешеного темпа поисков и работы мысли начинало становиться очевидным и пугающим для родителей. В какой-то момент он не спал около 30 часов подряд, отказывался от еды и терял нормальную координацию движений.
В означенное время на `845145127.com` появились координаты 14 точек на поверхности планеты и просьба найти ближайшую к местоположению ищущего разгадку.
Из них восемь находились в разных городах США, по две в Париже и Сеуле, одна в Варшаве и одна в австралийском Эрскенвиле, пригороде Сиднея. По воспоминаниям участников, это было изрядно крипово: интернет-загадка прорвалась в реальный мир, причём в глобальных масштабах. Испуганные дешифраторы гадали, кто же стоит за «Цикадой»? Спецслужбы? Тайные общества? Хакеры-Анонимусы? Или лично Уильям Гибсон, отец киберпанка, некоторые романы которого имели схожие мотивы?
И это было проблемой! Ни подростки-школьники Маркус и Текк, ни обитатель глухой норвежской глубинки Гутторм не могли просто взять билет на самолёт и рвануть в Сиэтл, Майами, Париж или Сеул! Им пришлось призвать на помощь Анонимуса и выложить находки в большой IRC-чат двачеров.
Начался яростный поиск с привлечением друзей, знакомых, знакомых друзей и друзей знакомых. Как ни странно, первым удалось добраться до точки близ Сиднея. Там обнаружился примотанный к столбу плакат с QR-кодом и изображением всё той же цикады. Затем такие же плакаты нашли и в других указанных координатах.
При сканировании с помощью QR-ридера коды привели к двум фрагментам дальнейших указаний в сопровождении книжного кода из пар цифр. Одно сообщение ссылалось на шестой том 11-го издания Британской энциклопедии, в котором как раз содержалась статья «Цикада». Другое — на стихотворение «Агриппа / Книга мёртвых» Уильяма Гибсона.
Стихотворение 1992 года было необычным, весьма киберпанковым и несколько даже криповым по оформлению. Оно распространялось на дискете, вложенной в обложку художественного альбома Денниса Эшбо поверх буквенной записи ДНК-кода. Программный код под Mac System 7 на дискете позволял прочитать стихотворение лишь раз, после чего поэма превращалась в набор символов без возможности восстановления.
(Правда, текст поэмы был распространён фанами в день премьеры, есть и [перевод на русский язык](https://libcat.ru/knigi/proza/sovremennaya-proza/175481-uilyam-gibson-agrippa-kniga-mertvyh.html)).
Оба сообщения «Цикады» содержали следующее послание: «До сего момента вы делились слишком многим. Нам нужны лучшие, а не последователи. Лишь первые получат награду».
Книжный код вёл на сайт в даркнете по адресу `sq6wmgv2zcsrix6t.onion`. Там прибывших ждало предложение ввести адрес электронной почты, на которую лишь самые первые зашедшие получат уникальные личные коды для дальнейшего продвижения.
Дальнейшее мы знаем исключительно со слов тех немногих вроде Маркуса или Текка, которые согласились рассказать о своём опыте взаимодействия с «Цикадой» спустя годы. Достоверность того, что было дальше, неясна — но внятно докопаться до правды до сих пор не удалось никому.
О чём мы и расскажем [во второй](https://habr.com/ru/company/ruvds/blog/716260/) и последней (пока что?) части рассказа о «Cicada 3301» — одной из величайших нерешённых загадок интернета.
> **[Играй в наш скролл-шутер прямо в Telegram и получай призы! 🕹️🎁](https://t.me/ruvds_community/170)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Erwinmal&utm_content=cicada_3301_kogo_i_kuda_dolzhny_byli_otobrat_zagadki_tainstvennoj_cikady) | https://habr.com/ru/post/714806/ | null | ru | null |
# Паттерн: Сага
Привет, Хабр! Представляю вашему вниманию перевод статьи ["Pattern: Saga"](https://microservices.io/patterns/data/saga.html) автора Chris Richardson.
Ситуация
--------
Есть приложение, к которому применялся паттерн [Database per Service](https://microservices.io/patterns/data/database-per-service.html). Теперь у каждого сервиса приложения есть своя собственная база данных. Некоторые бизнес транзакции охватывают сразу несколько сервисов, так что нужен механизм, обеспечивающий согласованность данных между этими сервисами.
Например: давайте представим, что мы разрабатываем интернет магазин, где у клиента есть кредитный лимит. Приложение должно гарантировать, что новый заказ не превышает кредитный лимит клиента. Так как Заказы и Клиенты — различные базы данных, то приложение не может использовать локальные ACID транзакции.
Проблема
--------
Как обеспечить согласованность данных между сервисами?
Решение
-------
Необходимо каждую бизнес транзакцию, которая охватывает несколько сервисов, реализовывать как сагу.
**Сага** представляет собой набор локальных транзакций. Каждая локальная транзакция обновляет базу данных и публикует сообщение или событие, инициируя следующую локальную транзакцию в саге. Если транзакция завершилась неудачей, например, из-за нарушения бизнес правил, тогда сага запускает компенсирующие транзакции, которые откатывают изменения, сделанные предшествующими локальными транзакциями.
Существует два способа координации саг:
* Хореография (Choreography) — каждая транзакция публикует события, которые запускают транзакции в других сервисах.
* Оркестровка (Orchestration) — оркестратор говорит участникам, какие транзакции должны быть запущены.
### Пример: сага, основанная на хореографии
В интернет магазине с использованием саги, основанной на хореографии, создание заказа будет включать следующие шаги:
1. `Order Service (Сервис Заказа)` создает `Order (Заказ)` в статусе *pending (в ожидании)* и публикует событие `OrderCreated (ЗаказСоздан)`
2. `Customer Service (Сервис Клиента)` получает событие и пытается зарезервировать кредит для заказа. После чего публикует одно из двух событий: `CreditReserved (КредитЗарезервирован)` или `CreditLimitExceeded (КредитныйЛимитПревышен)`
3. `Order Service (Сервис Заказа)` получает событие и изменяет состояние заказа в *approved (подтвержден)* или *cancelled (отменен)*
### Пример: сага, основанная на оркестровке
В интернет магазине с использованием саги, основанной на оркестровке, создание заказа будет включать следующие шаги:
1. `Order Service (Сервис Заказа)` создает `Order (Заказ)` в статусе *pending (в ожидании)* и создает `CreateOrderSaga (СагаСозданияЗаказа)`
2. `CreateOrderSaga (СагаСозданияЗаказа)` отправляет команду `ReserveCredit (ЗарезервироватьКредит)` в `Customer Service (Сервис Клиента)`
3. `Customer Service (Сервис Клиента)` пытается зарезервировать кредит для заказа и отправляет назад ответ
4. `CreateOrderSaga (СагаСозданияЗаказа)` получает ответ и отправляет `ApproveOrder (ПодтвердитьЗаказ)` or `RejectOrder (ОтменитьЗаказ)` команду в `Order Service (Сервис Заказа)`
5. `Order Service (Сервис Заказа)` изменяет состояние заказа в *approved (подтвержден)* или *cancelled (отменен)*
### Сага имеет следующие преимущества
* Позволяет приложению поддерживать согласованность данных между сервисами без использования распределенных транзакций.
### Сага имеет следующие недостатки
* Модель программирования становится более сложной. Например, разработчики должны проектировать компенсирующие транзакции, которые отменяют изменения, сделанные ранее в саге. | https://habr.com/ru/post/427705/ | null | ru | null |
# Эмулятор PS2 на Android — ёжик плакал и кололся, но продолжал есть кактус
Привет всем читателям!
Я продолжаю тему программного эмулятора для PlayStation 1, PlayStation 2 и PlayStation Portable — Omega Red. Более подробно:
* [Редизайн пользовательского интерфейса эмулятора Omega Red (Вторая серия)](https://habr.com/ru/post/517150/)
* [Редизайн пользовательского интерфейса эмулятора Omega Red](https://habr.com/ru/post/514392/)
* [4К (2160р) разрешение для игр PS1, PS2, PSP в эмуляторе Omega Red](https://habr.com/ru/post/512914/)
* [Видео гид по эмулятору Omega Red](https://habr.com/ru/post/510598/)
* [Поддержка геймпада для эмулятора Omega Red](https://habr.com/ru/post/498990/)
* [Новый PS1 графический рендерер для эмулятора Omega Red](https://habr.com/ru/post/484620/)
* [Omega Red + PS1 эмулятор = Кодзима гений](https://habr.com/ru/post/476958/)
* [PS2/PSP эмулятор + game play streaming (YouTube, Facebook, Twitch) = новая версия Omega Red](https://habr.com/ru/post/456842/)
* [PS2/PSP эмулятор + Google Drive + YouTube = «безумие» продолжается](https://habr.com/ru/post/450648/)
* [Как я подружил PlayStation 2 и PlayStation Portable (спойлер — объединил в один эмулятор)](https://habr.com/ru/post/445022/)
* [Красный Омега PS2 эмулятор](https://habr.com/ru/post/415851/)
Данную новость я написал в связи с решением портировать часть кода разрабатываемого мной эмулятора на Android — ARM64 платформу. Поспешу предупредить, что скачать и запустить не получиться — проект только на начальной стадии развития. Однако, для тех читателей, кто не лишён профессионального любопытства — добро пожаловать под кат.
P.S. Новая версия эмулятора для Windows OS (с поддержкой гемпадов по старому протоколу — DirectInput8) доступна по ссылке: [Omega Red](https://www.buymeacoffee.com/omegared).
Для любопытствующих — проект был инициирован больше года назад и мой интерес к нему возгарался и затухал циклически. Но лишь недавно мне удалось закончить первый этап — добиться корректной компиляции и линковки кода.
Основой портирования я решил взять центральное ядро эмулятора PCSX2, переписанное мной в форме отдельной динамически загружаемой библиотеки (подробно [«Красный Омега PS2 эмулятор»](https://habr.com/ru/post/415851/)). Стартовая версия библиотеки была написана для Windows OS на Microsoft Visual Studio — как результат, существует объективная проблема в совместимости сред разработки-компиляции и совместимости сред выполнения кода библиотек. Длительная работа с библиотекой ядра эмулятора позволила разработать паттерн алгоритма внешнего исполняемого кода по отношению библиотеке через разработанный API.
Первой задачей было написание кода для этого алгоритма на Java для Android. Программный код достаточно сложен по причине наличия большого количества функций «обратного» вызова — библиотека ядра эмулятора включает три программных потока исполнения кода и они потребуют данных для обработки — БИОСа, данных геймпадов, загрузки плагинов. В коде для Windows OS на WPF C# задача реализации «обратного» вызова проста через встроенный механизм маршалинга данных. Но для Java виртуальной машины маршалинг данных из нативного кода С++ в виртуальную машину и обратно становиться крупной проблемой. Для этого я определил отдельный С++ файл AndroidInterface.cpp в PCSX2Lib с определением Java Native интерфейсов в следующем виде:
```
extern "C"
JNIEXPORT void JNICALL
Java_com_xirexel_omegared_PCSX2_PCSX2LibNative_NativeSetElfPathFunc(JNIEnv *env,
jobject instance,
jstring a_config_) {
const char *a_config = env->GetStringUTFChars(a_config_, 0);
PCSX2_Hle_SetElfPathFunc(a_config);
env->ReleaseStringUTFChars(a_config_, a_config);
}
```
Загрузка нативного кода происходит стандартным образом:
```
public final class PCSX2LibNative {
static {
System.loadLibrary("PCSX2Lib");
}
```
Вызов Java методов из С++ кода имеет следующий вид:
```
static void callOnePtrTwoIntBoolean(const std::string& aMethodCallback, unsigned char* arg1, int arg2, int arg3, bool arg4)
{
if(s_JavaVM == nullptr)
return;
JNIEnv* l_Env = nullptr;
const jint get_res = s_JavaVM->GetEnv(reinterpret_cast(&l\_Env), JNI\_VERSION\_1\_6);
if (get\_res == JNI\_EDETACHED) {
if (s\_JavaVM->AttachCurrentThread(&l\_Env, NULL) != 0) {
return;
}
} else if (get\_res != JNI\_OK) {
return;
}
jclass l\_PCSX2LibNative = l\_Env->GetObjectClass(g\_PCSX2LibNative);
jmethodID methodId=l\_Env->GetMethodID(l\_PCSX2LibNative, aMethodCallback.data(), "(Ljava/nio/ByteBuffer;IZ)V");
jobject l\_buffer = l\_Env->NewDirectByteBuffer(arg1, arg3);
l\_Env->CallVoidMethod(g\_PCSX2LibNative, methodId, l\_buffer, arg2, arg4);
}
```
Второй задачей было создание CMake скрипта для корректной компиляции нативного кода для Android проекта. Получилось следующее:
```
# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html
# Sets the minimum version of CMake required to build the native library.
cmake_minimum_required(VERSION 3.4.1)
set (EXTEND_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Extend)
set (PCSX2LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../PCSX2Lib)
set (PCSX2_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../../pcsx2)
set (FRAMEWORK_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Common/Framework)
set (UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Common/Utilities)
set (MEMORYMANAGER_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Common/MemoryManager)
set (PUGIXML_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Common/PugiXML)
set (FRAMEWORK_UTILITIES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Common/Framework/Utilities)
set (PCSX2_UTILITIES_SRC_DIR ${PCSX2_DIR}/../common/src/Utilities)
set (PTHREADS_INC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Common/pthreads4w/include)
set (LIBAIO_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libaio/src)
set (MODULES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../Modules)
add_definitions(-DDISABLE_RECORDING -DPUGIXML_WCHAR_MODE)
if(${ANDROID_ABI} STREQUAL "x86")
add_definitions(-DANDROID_ABI_X86)
endif()
if(
(${ANDROID_ABI} STREQUAL "x86")
)
message(ANDROID_ABI = ${ANDROID_ABI})
set(SVU_ZEROREC_SRC
${CMAKE_CURRENT_SOURCE_DIR}/CPU/x86/aVUzerorec.S
)
add_subdirectory(libaio)
add_subdirectory(Framework)
add_subdirectory(Utilities)
add_subdirectory(Emitters)
add_subdirectory(MemoryManager)
add_subdirectory(PugiXML)
add_subdirectory(PCSX2Lib)
add_subdirectory(Modules)
add_subdirectory(BiosControl)
endif()
```
Полагаю что читатели сразу поняли причину, почему проект невозможно загрузить на смартфон — нативный код компилируется только для процессоров х86 архитектуры.
В настоящий момент проект бесполезен почти полностью — но только почти. Текущий результат показал следующее:
1. разработка отдельной библиотеки нативного кода для PCSX2 эмулятора было правильным решением, упростившем портирование на другую платформу;
2. корректная компиляция и линковка кода указывает на совместимость кода PCSX2 эмулятора с библиотеками компиляции Android NDK.
Как очевидно, в настоящий момент проблемой является написание кода для ARM64 процессоров — проблема объективно сложная, но на мой взгляд решаемая. Для любителей повозиться с кодом — проект для среды разработки Android Studio доступен на GitHub: [AndroidStudio](https://github.com/Xirexel/OmegaRed/tree/AndroidStudio).
В настоящий момент Windows OS версия программы доступна по ссылке: [Omega Red](https://www.buymeacoffee.com/omegared) и представлена на GitHub: [OmegaRed](https://github.com/Xirexel/OmegaRed).
[](https://www.buymeacoffee.com/omegared). | https://habr.com/ru/post/520744/ | null | ru | null |
# Сказ о курсовой
Здравствуйте. Я хочу рассказать о своей курсовой или к чему приводит любопытство.
Давно от нечего делать пишу программки под симбиан. И время от времени сталкивался со странностями при сборке. Все указывало на утилиту elf2e32. Ее задача — преобразование входного бинарного файла формата elf в другой, специфичный для Symbian — e32 image. Меня долго донимало любопытство — как вообще работает эта утилита и почему порой глючит? Немного позже меня начал донимать другой вопрос — тема курсовой работы =) Решил совместить приятное с полезным и скачал ее исходный код. И понеслось...
Первый коммит — не собирается
Второй — включаем нестандартные расширения gcc, добавляем из исходников отсутствующие классы, функции, константы. Сабж радостно собирается и падает. Прогресс однако. Запускаем под отладчиком — отладчика заносит в класс который лишь инициализирует другой, который иинициализирует следующий… Ура! Настоящая функция! Зааходим. Упс. Где мы?!!! Стоп отладчик! Хирург! Скальпель! Спирт! Огурчик! Классы-аппендиксы ф топку! Даёшь nullptr вместо NULL! У нас С++14! Ух какой устрашающий конструктор инициализующий всё нулями! И ещё, и ещё, и опять — но у нас C++14 призывает инициализацию по умолчанию для классов! Какое всё теперь лаконичное...
Лаадно. Исправляем как можно больше за раз. Разобрался-таки почему отладчик скачет по исходникам аки припадочный — афтары ударились головой об абстракцию, вырастив наследование 80 левела из класса UseCaseBase :) Тогда видимо из глаз и полетели классы-конструкторы статических экземпляров для классов Message & ParameterManager. Синглтон Майерса? Нет, не слышали. Ф топку абстракцию! Viva revolucion!!! Viva POD!!!
Ух! Как интересно это дерево растили. Основную работу делает функция BuildAll(). Если заданы все параметры, функция собирает библиотеку импорта, файл задающий имена функций и переменных и порядок в котором они доступны в библиотеке импорта и собственно сам бинарник. Все потомки UseCaseBase меняли ее алгоритм через перегрузку. Порой в потомках подготавливаем вспомогательные данные, но чаще всего просто выключали создание некоторых файлов. Например не задано имя файла для сборки чего-нибудь — создается новый класс. Идиоты. Достаточно прервать выполнение такой функции-сборщика если надо. Несложно понять мои действия B-)
Продолжаем удалять пустые классы, заменяем NULL на nullptr\_t, заменяем range-итераторы на for(auto x: \*).
Исправляем ошибки в обработке параметров коммандной строки.
Надо проверить код статическим анализатором. С чего начать? Хм, под XPшкой выбор небольшой — cppcheck, и codeblock поддерживает его из коробки. Ого какой улов! Есть даже delete для char[]! Блин, я знаю куда полгига свободной RAM делось =)
Так добавляем файлы сгенериванные из elf-файла libcrypto.dll и сам файлик описывающий параметры коммандной строки для их создания.
Упс. CPPCheck ошибся… Должно быть (a||b)...
Попробую собрать в Visual Studio 15 да и Win10 потыкать бы палкой. Поставим на виртуальную машину. Сделано, качаем и запускаем онлайн установщик студии. Что? Не хочет сохранять скачку в папку общую с хостом?! Да подавись ты! Качай куда тебя научили… А теперь переносим скаченное в папку и запускаем установку. Что? Опять игнорирует shared folder??! Да подавись ты! Становись куда тебя научили...
В принципе десятка неплохо шебуршит на одном ядре и 3 гигах рамы. Студию в студию! Призадумалось, но не надолго. Открываем мой проект в студиии Опять ругается на папку… Сколько уже можно? Да подавись ты… Собираем, ругается на нестандартное расширения STL hash\_set. Удаленное. Удаленное??? Включаем мозг =)
Ух какой забористый код:
```
int ElfFileSupplied::UnWantedSymbolp(const char * aSymbol)
{
static hash_set, eqstr> aSymbolSet;
int symbollistsize=sizeof(Unwantedruntimesymbols)/sizeof(Unwantedruntimesymbols[0]);
static bool FLAG=false;
while(!FLAG)
{
for(int i=0;i, eqstr>::const\_iterator it
= aSymbolSet.find(aSymbol);
if(it != aSymbolSet.end())
return 1;
else
return 0;
}
```
Немного подумаем… И вуаля:
```
int ElfFileSupplied::UnWantedSymbolp(const char * aSymbol)
{
int symbollistsize = sizeof(Unwantedruntimesymbols) / sizeof(Unwantedruntimesymbols[0]);
for (int i = 0; i
```
Моя преелесссстььь...
Так с, почему программа бросает исключение если этот флаг неправильно установлен или не установлен вообще? Зачем ты так жестоко, прекрасное далёко… Давайте-ка будем просто сбрасывать этот флаг на безопасное значение. И этот флаг тоже хорошо бы… И этот, и этот, и эти. А может это лучше вынести в отдельную функцию? Хорошая идея! Назовем её ParameterManager::CheckOptions()!
Шаг влево — падение, шаг вправо — неотловленное исключение, прыжок на месте — спасибо хоть не BSOD =)
Скуучно… Глюки и кривизна...
Оля-ля!!! Эмуляция CleanUpStack Symbian на STL?:
В принципе ничего особого:
```
std::vector cleanupStack;
```
Очистка:
```
std::vector::iterator aPos;
char \*aPtr;
aPos = cleanupStack.begin();
while( aPos != cleanupStack.end() )
{
aPtr = \*aPos;
delete[] aPtr;
++aPos;
}
```
Какая-то светлая голова вместо left/right иcпользовала l/r. Спасибо cppcheck.
Ай, лениво перед монитором логи cppcheck разбирать… Что гитхаб нам предложит?.. Codacy… Подключаем проект… Немного подумал и готово! Теперь можно читать сообщения об успехах в борьбе с ошибками лежа на диване ^^
Так-с вроде не глючит… Соберем что-нибудь, например libcrypto.dll. Работает, хотя несжатый файл больше на сто байт чем созданный утилитой из SDK. Далее будет постоянно сравниваться бинарники созданные этой версией утилиты и из SDK. Параметры командной строки само собой идентичны.
Такс, где взять аналог diff для бинарных файлов? Хм, наваяю-ка скрипт на пистоне. Слишком много информации — надо что-то сильно проще. Dll для распознавания pdf/djvu — AlternateReaderRecog.dll — хороший вариант, выхлоп менее 4 килобайт. Такс, смещения различаются в import section. Открываем их в hex-редакторе. Начало совпадает, в моей версии дальше мусор, как раз после окончании секции в оригинальной версии. Но в моей версии следующая секция начинается на 100 байт позже. На эту же величину в байтах файлы и различаются! Смещения далее указывают на верные адреса… Бинарник корректен!!! Ааааа!!!
Месяц спустя. Так, откуда взялись эти сто байт?
Что ж, раз непонятно как работает — начинаем ломать алгоритм создания E32Image. Продолжаем издеваться над AlternateReaderRecog.dll. Увеличиваем размер бинарника на выходе — никак, затираем memset секции — никак, уменьшаем размер бинарника — никак. Грррр. Что за?!!! Я ломаю выхлоп в релизной версии, а запускаю отладочную?!!! Привет мочало, начинай сначала… Тааак секция затерлась — хорошо! Увеличили размер бинарника! Хорошо!!! Уменьшим-ка размер секции импорта! Есть!!! Побайтово идентична этой же секции в выхлопе этой утилиты из SDK!
Смотрим в код создания этой секции. "sizeof(char\*)" — что-то вспомнились статьи Андрея Карпова, одного из разработчиков Pvs-studio, о том что типы могут занимать разный объём памяти — и сколько же он занимает места? MinGW — 8 байт, Visual Studio — 4!!! Делим пополам эти 8 байт, делов-то. ФФсе! А секция кода как? Эта дллка без глобальных переменных. Нет глобальных переменных — нет и секции… Возьмем что-нибудь потяжелее — libcrypto.dll.
Файл на выходе моей утилиты теперь меньше на 100+ байт… Какого??? Секция импорта побайтово идентичны — хорошо. Секция кода — нет?!!
На глаз сравнивать такую стену текста я не шмогу… Пойду поищу diff для побайтового сравнения…
Через пару дней игры с гуглопоиском всё же нашёл. vbindiff — консольная утилита с интерфейсом аля Norton Commander, показывающая различие между двумя файлами в двух горизонтальных панелях. Для перехода к месту отличия жмем ввод. Хорошо! Можно перетянуть на иконку два файла для сравнения и программа их откроет! Отлично!!!
Сравниваем — тааак в заголовке отличаются его crc и время создания. Ничего такого. Вот байтик отличается, вот ещё сотня… Ого!!! Десятки, сотни, тысячи байт разницы?!!! Таак, смотрим смотрим какой секции они принадлежат… Смотрим смещения… Ага, секция данных…
Проворачиваем трюк, что и для секции импорта… Обнуляем memset'ом, есть. Увеличиваем размер секции… Падает… Увеличиваем. Предлагает руку и сердце отладчика… Блин. Открываем функцию создающую секцию — каша из функций… Грр.
… Ай, завтра… Пока исправлю что-нибудь другое...
Например добавлю тесты, но тут такая каша, что невозможно разделить программу на небольшие модули. Вставлять тесты прямо в код нельзя — потом хрен разберешь. Идея! Постоянные запуски программ с разными аргументами — я же так все время тестировал программу… А давай-ка лучше это всё оформим отдельным скриптом на питоне. Да отличная идея, просто отличная. Скрипт при ошибках выполнения теста должен продолжать работать сообщая о них но не падать. Вот и готово!
Возвращаемся к нашим баранам… Эта функция вызывает эту, затем эту, идём сюда… Так-с, куда меня занесло? Тьфу, запутался…… Ай, завтра… Пока исправлю что-нибудь другое...
И так прошло два месяца...
Блин, где формируется эта секция кода? Пришлось уйти в академический отпуск, так хоть с тобой разберусь!!! Таак. Сюда на вход идут символы для секции… Что покажет printf? В буфер консоли всё не влазит… Сохраним выхлоп в файл… Таак, пока ничего особого… Стоп! Одинаковые строки!!! Много одинаковых строк!!! Откуда?! Добавляем printf на каждый источник данных (терпения хватило на 3 из пяти, ха). Пусто! Смотрим один из оставшихся вызовов функции… Таак. Приращение итератора после цикла??? И TODO на предупреждение codacy??? Переносим в цикл. Запуск!!! Есть совпадение размера! Есть побайтовое совпадение!!! Исправлено!!! git blame имя героя отказывается назвать… Смотрим оригинал — такое не я сотворил. А может это была "бомба" для разработчиков не связанных с Nokia? Гррр.
Тщательно проверяем выхлоп тестов, сверяем побайтово файлы. Все работает как надо! В релиз!
Оляля! Пришло Время Большой Чистки!!! Пора выкорчевать древо UseCaseBase с корнем!!!
Большую часть потомков уже извел, выносим полезные функции в класс-генератор. Остались только UseCaseBase и его потомок ElfFileSupplied. UseCaseBase — представляет собой обертку над классом, обрабатывающим параметры командной и объявляющий несколько чисто виртуальных функций для класса ElfFileSupplied. Короче скрипач не нужен… Какое небо голубое, хорошо… Еще часок… Разберусь с этим классом и можно пойти погулять… И подышать воздухом, погреться, хорошо… Поехали! Так, закомментировать эту функцию. Собираем! Тааак надо подумать как это красиво переделать… Готово!!! Следующая функция! Готово! Следующая! Готово! Готово! Да! Да! Да! Последняя функция… Уффф. Запускаем после сборки… Семикратное ускорение работы?!!! Выхлоп корректный… Забавно. Отладочная версия тоже усохла на 2 метра?!!! Ничего себе!!! Можно и погулять. Ночью?!!! Каак??? Где мой день?!!! Лаадно запущу тесты и отдыхать… Тесты тихо отработали — можно и отдохнуть...
Дай-ка я теперь свое что-нибудь напишу… О, класс работающий с функциями и переменными доступными извне выглядит жутковато. Принцип работы: чтение из файла, разбор строк и сохранение в файл. Под разбор строк выделили аж целый класс отборной лапши на С… Тааак… Подумаеем… Какая красота вышла:
читаем строку std::getline(), удаляем пробелы с краев строк и парсим.
Продолжение следует… Исходный код — <https://github.com/fedor4ever/elf2e32> | https://habr.com/ru/post/430794/ | null | ru | null |
# Быстрый ввод в Java
Доброго времени суток!
Данная статья будет полезна для прикладных программистов или людей, увлекающихся спортивным программированием. Она расскажет о быстром вводе данных на языке Java.
Я часто решаю задаче на сайте [www.spoj.pl](http://www.spoj.pl) и иногда сталкиваюсь с проблемами скорости java. В основном это касается довольно медленного ввода данных, для некоторых задач не подходит даже **StreamTokenizer**.
С этой целью я написал класс, который побайтово считывает данные из потока и преобразует их в числа или строки. Как оказалось этот класс работает в несколько раз быстрее, чем scanf() в языке С++. Привожу его код ниже:
> `Copy Source | Copy HTML1. import java.io.DataInputStream;
> 2. import java.io.InputStream;
> 3.
> 4.
> 5. class Parser {
> 6. final private int BUFFER\_SIZE = 1 << 16;
> 7. private DataInputStream din;
> 8. private byte[] buffer;
> 9. private int bufferPointer, bytesRead;
> 10.
> 11. public Parser(InputStream in) {
> 12. din = new DataInputStream(in);
> 13. buffer = new byte[BUFFER\_SIZE];
> 14. bufferPointer = bytesRead = 0;
> 15. }
> 16. public String nextString(int maxSize) {
> 17. byte[] ch = new byte[maxSize];
> 18. int point = 0;
> 19. try {
> 20. byte c = read();
> 21. while (c == ' ' || c == '\n' || c=='\r')
> 22. c = read();
> 23. while (c != ' ' && c != '\n' && c!='\r') {
> 24. ch[point++] = c;
> 25. c = read();
> 26. }
> 27. } catch (Exception e) {}
> 28. return new String(ch, 0,point);
> 29. }
> 30. public int nextInt() {
> 31. int ret = 0;
> 32. boolean neg;
> 33. try {
> 34. byte c = read();
> 35. while (c <= ' ')
> 36. c = read();
> 37. neg = c == '-';
> 38. if (neg)
> 39. c = read();
> 40. do {
> 41. ret = ret \* 10 + c - '0';
> 42. c = read();
> 43. } while (c > ' ');
> 44.
> 45. if (neg) return -ret;
> 46. } catch (Exception e) {}
> 47. return ret;
> 48. }
> 49. public long nextLong() {
> 50. long ret = 0;
> 51. boolean neg;
> 52. try {
> 53. byte c = read();
> 54. while (c <= ' ')
> 55. c = read();
> 56. neg = c == '-';
> 57. if (neg)
> 58. c = read();
> 59. do {
> 60. ret = ret \* 10 + c - '0';
> 61. c = read();
> 62. } while (c > ' ');
> 63.
> 64. if (neg) return -ret;
> 65. } catch (Exception e) {}
> 66. return ret;
> 67. }
> 68. private void fillBuffer() {
> 69. try {
> 70. bytesRead = din.read(buffer, bufferPointer = 0, BUFFER\_SIZE);
> 71. } catch (Exception e) {}
> 72. if (bytesRead == -1) buffer[ 0] = -1;
> 73. }
> 74.
> 75. private byte read() {
> 76. if (bufferPointer == bytesRead) fillBuffer();
> 77. return buffer[bufferPointer++];
> 78. }
> 79. }`
Проверить или сравнить скорость ввода данных можно на задаче [INTEST](http://www.spoj.pl/problems/INTEST/) | https://habr.com/ru/post/91283/ | null | ru | null |
# Характер Kotlin
Привет, Хабр! Надеемся в обозримом будущем и до Kotlin добраться. Мимо этой статьи (февральская) пройти не смогли.
Читаем и комментируем!
Я только что дочитал книгу [Брюса Тейта](https://en.wikipedia.org/wiki/Bruce_Tate) "[Семь языков за семь недель](https://pragprog.com/book/btlang/seven-languages-in-seven-weeks)" — и с тех пор ее обожаю! Хотя, у меня и есть опыт работы с большинством языков, описанных в книге, мне очень понравилось, как именно автор характеризует языки, и как эти характеристики в итоге отражаются на практическом использовании языка.
Поэтому я и решил написать для этой книги еще одну главу, дополнительную. Она будет посвящена языку, который я знаю достаточно хорошо, понимаю его достоинства и недостатки: это Kotlin.
*Цель этой статьи – не научить вас языку Kotlin, а показать его характер. Не пытайтесь понять ее досконально. Лучше уделите внимание тому, как описанные здесь возможности могли бы повлиять на ваш стиль программирования.*
Типичнейшая черта Kotlin заключается в том, что этот язык, в сущности, не вводит ничего такого, что бы еще не встречалось в других языках программирования. Дело в том, что Kotlin использует все эти старые находки самым шедевральным образом. Вспомните супергероя Железного Человека. Тони Старк собрал Железного Человека из простейших электронных комплектующих. У Железного человека нет таких характерных сверхвозможностей, как у Супермена или Флэша. Это может показаться слабостью, однако, в долгосрочной перспективе это огромное преимущество. Поговорим об этом ниже, а пока начнем с азов.
### Основы
Считается, что Kotlin предназначен для программирования в той или иной IDE – например, в IDEA IntelliJ, Android Studio или CLion (Kotlin/Native). Здесь мы начнем с командной строки, чтобы продемонстрировать Kotlin в более простом контексте. После того, как [установите Kotlin](https://kotlinlang.org/docs/tutorials/command-line.html), запустите REPL (интерактивную оболочку) вот так:
Попробуем с числами:
```
>>> 1
1
>>> 1 + 2
3
>>> 1.0 + 2
3.0
```
Простая математика работает. Это Kotlin/JVM, работающий на виртуальной машине Java. Целые числа в Java – это примитивы. А в Kotlin? Давайте проверим тип числа:
```
>>> 1::class
class kotlin.Int
>>> 1.0::class
class kotlin.Double
```
Оба – объекты! Вообще, в Kotlin все сущности – это объекты. Что насчет Java? Kotlin полностью интероперабелен с Java, но мы видим, что вышеприведенные типы – это типы Kotlin. Дело в том, что некоторые встроенные типы Kotlin покрывают типы Java. Можно посмотреть, каков в данном случае будет тип Java, воспользовавшись свойством `java` от `Class` или свойством `javaClass` любого объекта:
```
>>> 1.0::class.java
double
>>> 1.0.javaClass
double
```
Это `double`! Числа двойной точности (double) в Java — примитивы. Как это возможно? Kotlin задействует оптимизацию, позволяющую применять примитивы вместо объектов, когда никакие объектно-ориентированные возможности не используются. Это происходит под капотом, совершенно не касается разработчика. Если нам требуется использовать `double` как объект, то вместо него пойдет в ход `Double`. С точки зрения разработчика по-прежнему можно сказать, что «все является объектом». Определим несколько свойств:
```
>>> val a = 1
```
Это свойство только для чтения. Также можно определить свойство для чтения и для записи при помощи `var`:
```
>>> var a = 1
```
Обратите внимание: тип здесь не указан. Однако, пусть это не вводит вас в заблуждение: Kotlin – язык с сильной статической типизацией. Тип свойства просто выведен из типа присвоенного значения:
```
>>> ::a.returnType
kotlin.Int
```
Довольно математики, перейдем к более интересным возможностям.
### Безопасность
Железного человека сконструировали потому, что ни полиция, ни армия не могли вызволить Тони Старка из плена террористов. Тони сделал Железного Человека, чтобы позаботиться о собственной безопасности, а также расширить свои возможности. Еще он этим прославился.
Точно так же JetBrains создали Kotlin. Эта же компания создает самые популярные интегрированные среды разработки. Все их инструменты изначально создавались на Java, но команда JetBrains на практике ощутила все недостатки этого языка. Тогда компания стала экспериментировать с другими языками, например, Scala или Groovy, но и они их не удовлетворили. Поэтому, в конце концов JetBrains решили создать собственный язык, с прицелом на то, что этот новый язык должен обеспечивать максимальную безопасность (чтобы в продуктах не возникало ошибок) и масштабируемость. Кроме того, Kotlin отлично пропиарил JetBrains. Они и так были известны во всем мире, а когда появилось сообщество специалистов, решивших пользоваться их обалденным языком, JetBrains стала для них еще круче. (Здесь я лишь в самых общих чертах пересказал эту историю. Если интересуют детали – послушайте [этот подкаст](https://github.com/artem-zinnatullin/TheContext-Podcast/releases/tag/Episode_10)).
Kotlin значительно выигрывает у Java по части безопасности. Свойства необходимо инициализировать:
```
>>> var a: String
error: property must be initialized or be abstract
```
По умолчанию типы не обнуляемы:
```
>>> var a: String = null
error: null can not be a value of a non-null type String
```
Если мы хотим показать, что данный тип обнуляем, это делается при помощи `?`:
```
>>> var a: String? = null
```
Правда, обнуляемый тип нельзя явно использовать:
```
>>> a.length
error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
```
Обнуляемые типы похожи на другие, например, на опциональные типы, используемые в Scala. Перед использованием такой тип нужно распаковать. Можно воспользоваться безопасным вызовом, действующим точно как нормальный вызов, если свойство не равно `null`. Если свойство равно `null`, то мы не вызываем метод, а просто возвращаем `null`:
```
>>> a = null
>>> a?.length
null
>>> a = "AAA"
>>> a?.length
3
```
Также можем использовать небезопасный вызов, который выбросит исключение, если свойство будет равно нулю;
```
>>> a = null
>>> a!!.length
kotlin.KotlinNullPointerException
```
Работать с небезопасными вызовами не рекомендуется, поэтому прибегать к ним нужно лишь в случае крайней необходимости. В проектах на Kotlin они встречаются очень редко. В этом огромное отличие Kotlin от Java, где все вызовы небезопасны.
### Интеллектуальность
Железный человек так крут, поскольку его боевой костюм по-настоящему интеллектуален. Он просчитывает ситуацию и предупреждает Тони об опасностях. Kotlin также по-настоящему интеллектуален, и тем самым очень помогает разработчикам.
Один из образцов такой интеллектуальности – умное приведение типов. Когда мы проверяем, не равно ли свойство нулю, мы можем использовать его так, словно оно действительно ненулевое. Чтобы продемонстрировать некоторые более продвинутые возможности, мы будем работать с файлами. Предлагаю воспользоваться IDEA IntelliJ ([здесь рассказано](http://kotlinlang.org/docs/tutorials/getting-started.html), как приступить к работе с ней). В качестве альтернативы можете попробовать все эти возможности в [онлайновой REPL](https://try.kotlinlang.org/). Рассмотрим пример:
```
fun smartCastingExample(str: String?) {
if(str != null)
print("Length is " + str.length)
}
```
Как видите, str используется явно (без небезопасных или безопасных вызовов). Вот почему в области проверки `if(str != null)` тип приводится от `String?` к `String`. Также все сработает, если мы выйдем из функции при противоположной проверке:
```
fun smartCastingExample(str: String?) {
if(str == null)
return
print("Length is " + str.length)
}
```
Принцип работает не только с обнуляемостью. Также возможно умное приведение к типу:
```
fun smartCastingExample(any: Any?) {
if(any is String)
print("String with length " + any.length)
}
```
Kotlin отлично поддерживается в IDEA IntelliJ, Android Studio или CLion. В этих IDE вы получите массу советов, подсказок и поддержки. Вот пример, где императивная обработка коллекции, типичная для Java, заменяется на декларативную, свойственную Kotlin. Обратите внимание, что именно среда разработки предлагает и выполняет весь переход:
### Минимализм
Тони Старк не облачается в Железного человека целиком, если ему это не требуется. Обычно он пользуется только машиной или некоторыми небольшими компонентами.
Философия Kotlin, в частности, постулирует, что простое должно оставаться простым. Вот код Hello World на Kotlin:
```
fun main(args: Array) {
print("Hello, World")
}
```
Это всего лишь одна функция, выводящая текст. Другие типичные операции на Kotlin также просты. Когда все тело функции нам не требуется, можно обойтись единственным выражением:
```
fun add(a: Int, b: Int) = a + b
```
Ниже вы еще не раз увидите точно такой же минималистичный стиль.
### Гибкость
Железный Человек проигрывает Супермену по некоторым важным показателям. Например, лазерные глаза даны Супермену от рождения, он может испепелять врага взглядом, когда ему вздумается. Тони Старк не оснащал Железного Человека глазными лазерами – возможно, потому, что не видел в этом острой необходимости. Здесь важно отметить, что он легко мог бы добавить Железному Человеку такую фичу. На самом деле, это под силу и любому пользователю Железного Человека. Но, при этом, на Железного человека можно навешивать и иные апгрейды, которые вполне могут быть не менее эффективны, зато обойдутся дешевле. В этом – огромный потенциал гибкости. Перейдем к практике. В большинстве языков программирования в той или иной форме предоставляются литералы коллекций. В Python, Ruby или Haskell список можно определить вот так: `[1,2,3]`. В Kotlin таких литералов коллекций нет, зато он предусматривает функции верхнего уровня (те, что могут использоваться везде), а в стандартной библиотеке Kotlin имеются такие функции верхнего уровня, при помощи которых можно создавать коллекции:
```
>>> listOf(1,2,3)
[1, 2, 3]
>>> setOf(1,2,3)
[1, 2, 3]
>>> mapOf(1 to "A", 2 to "B", 3 to "C")
{1=A, 2=B, 3=C}
```
Почему это так важно? Когда в языке предоставляется литерал коллекций, он же и определяет, как пользователь будет применять коллекции. У всех коллекций имеются некоторые характеристики. Идет обширная дискуссия о том, какие списки лучше – изменяемые или неизменяемые? Изменяемые эффективнее, но неизменяемые гораздо потокобезопаснее. По этому поводу есть множество мнений и доводов. С учетом этого, хотели бы вы, чтобы литерал списка порождал именно изменяемый, либо именно неизменяемый список? В любом случае, вы будете так или иначе навязывать программисту варианты использования языка, поскольку программист предпочтет воспользоваться литералом коллекций. Kotlin в данном случае оставляет свободу выбора. `listOf`, `setOf` и `mapOf` дают неизменяемые коллекции:
```
>>> var list = listOf(1,2,3)
>>> list.add(4)
error: unresolved reference: add
list.add(4)
^
>>> list + 4
[1, 2, 3, 4]
```
Хотя, не составляет труда создать и изменяемую коллекцию при помощи `mutableListOf`, `mutableSetOf` и `mutableMapOf`:
```
>>> mutableListOf(1,2,3)
[1, 2, 3]
>>> mutableSetOf(1,2,3)
[1, 2, 3]
>>> mutableMapOf(1 to "A", 2 to "B", 3 to "C")
{1=A, 2=B, 3=C}
```
Обратите внимание: кто угодно может определить собственную коллекцию, а затем – функцию верхнего уровня, которая будет ее создавать:
```
fun specialListOf(vararg a: T): SpecialList {
// Код
}
```
Выше легко заметить, что я воспользовался обобщенным параметром типа `T`. Не переживайте. Это означает, что необходимо передать набор однотипных элементов, чтобы создать коллекцию данного типа.
Благодаря тому, что в Kotlin используются базовые возможности, а не встроенные литералы, сторонние библиотеки при работе с Kotlin не уступают по силе его стандартной библиотеке. Еще одна великолепная фича, значительно демократизирующая библиотеки и развязывающая руки разработчикам – это так называемая функция-расширение (extension function). Суть в следующем: можно определить такую функцию, чтобы она действовала как метод:
```
>>> fun Int.double() = this * 2
>>> 2.double()
4
```
Обратите внимание: на практике при этом никаких методов к классу не добавляется. Функции-расширения – это просто функции, которые вызываются вот таким особым образом. Данная возможность может показаться простой, но она реально мощная. Например, в Kotlin, как и в других современных языках, предоставляются функции для обработки коллекций:
```
class Person(val name: String, val surname: String)
val avengers = listOf(
Person("Tony", "Stark"),
Person("Steve", "Rogers"),
Person("Bruce", "Banner"),
Person("Thor", "")
)
val list = avengers
.filter { it.surname.isNotBlank() }
.sortedWith(compareBy({ it.surname }, { it.name }))
.joinToString { "${it.name} ${it.surname}" }
print(list) // Выводит: Брюс Баннер, Стив Роджерс, Тони Старк
```
Огромное преимущество Kotlin заключается в том, что такие и подобные функции определяются как функции-расширения. Например, взгляните на реализацию `filter`:
```
inline fun Iterable.filter(
predicate: (T) -> Boolean
): List {
return filterTo(ArrayList(), predicate)
}
inline fun > Iterable.filterTo(
destination: C, predicate: (T) -> Boolean
): C {
for (element in this) if (predicate(element)) destination.add(element)
return destination
}
```
Если ее не стоит реализовывать, то можете определить эту функцию сами. Если вам нужна какая-либо иная функция для обработки коллекций, то можете без труда ее определить. Зачастую разработчики так и делают. Например, можно найти массу библиотек, в которых определяются функции-расширения для Android. Они упрощают разработку под Android. Еще один результат такого решения – к вашим услугам есть просто уйма методов для обработки коллекций.
Здесь также немаловажно отметить, что `filter` – это функция, расширяющая не тип `List`, а интерфейс `Iterable`:
```
public interface Iterable {
public operator fun iterator(): Iterator
}
```
Можете без труда определить свой класс коллекций, реализующий `Iterable`, и язык за вас добавит к нему эти методы для обработки коллекций. Даже `String` реализует его. Вот почему можно задействовать все методы обработки коллекций и со `String`:
```
>>> "I like cake!".map { it.toLowerCase() }.filter { it in 'a'..'z' }.joinToString(separator = "")
ilikecake
```
### Краткие итоги
Тони Старк не родился супергероем, и никакой радиоактивный паук его не кусал. Он сконструировал Железного Человека благодаря своим невероятным знаниям и опыту. Аналогично, JetBrains – это компания, создающая великолепные IDE для разных языков; ее люди многому научились за этой работой и воплотили свои знания, написав невероятный язык программирования. Они не привнесли в мир программирования ничего нового, а просто предложили идеально сработанный язык, в котором используются плюсы множества других языков программирования – поэтому на нем и достигается максимальная продуктивность разработчика и высочайшее качество проектов.
Отличный пример такого умного проектирования – кортежи Kotlin. Когда язык еще существовал в бета-версии, в нем уже поддерживались кортежи. Хотя, когда команда Kotlin проанализировала, как именно работа с кортежами сказывается на разработке программ, выяснилось, что их влияние не всегда положительно. Вот почему кортежи в релиз не попали. Вместо них в Kotlin можно применять аннотацию `data`. Она универсальнее, и разработчики Kotlin не сомневались, что в целом она положительно повлияет на работу с языком. Кортежи по-прежнему обсуждаются и, возможно, когда-нибудь в Kotlin появится нативная поддержка для них. Однако, чтобы это произошло, команда Kotlin и сообщество разработчиков должны убедиться в целесообразности такого решения.
Это красноречиво характеризует Kotlin. Это не сборная солянка из идей, а по-настоящему грамотно сделанный язык. В нем собран минимальный набор самых мощных фич, которые в сумме дают вам потрясающие возможности. В целом, Kotlin оставляет вам гораздо больше свободы – в том числе, для совместного творчества.
### Домашнее чтение
Если вы хотите подробнее разобраться с Kotlin, рекомендую почитать [документацию языка](https://kotlinlang.org/docs/reference/), а также познакомиться с ресурсом [Kotlin Koans](https://kotlinlang.org/docs/tutorials/koans.html). Если вас интересует Kotlin для Android, посмотрите [эту книгу](https://www.packtpub.com/application-development/android-development-kotlin). | https://habr.com/ru/post/353946/ | null | ru | null |
# Как передать полиморфный объект в алгоритм STL
Как мы можем прочесть в первой главе книги [Effective C++](https://www.amazon.com/gp/product/0321334876/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321334876&linkCode=as2&tag=fluentcpp-20&linkId=c827183fcb052e6a805d39ee7d66095), язык С++ является по сути своей объединением 4 разных частей:
* Процедурная часть, доставшаяся в наследство от языка С
* Объектно-ориентировання часть
* STL, пытающийся следовать функциональной парадигме
* Шаблоны
Эти четыре, по сути, подъязыка составляют то, что мы называем единым языком С++. Поскольку все они объединены в одном языке, то это даёт им возможность взаимодействовать. Это взаимодействие порой порождает интересные ситуации. Сегодня мы рассмотрим одну из них — взаимодействие объектно-ориентированной модели и STL. Оно может принимать разнообразные формы и в данной статье мы рассмотрим передачу полиморфных функциональных объектов в алгоритмы STL. Эти два мира не всегда хорошо контачат, но мы можем построить между ними достаточно неплохой мостик.
### Полиморфные функциональные объекты — что это?
Под функциональным объектом в С++ я понимаю объект, у которого можно вызвать operator(). Это может быть лямбда-функция или функтор. Полиморфность может означать различные вещи в зависимости от языка программирования и контекста, но здесь я буду называть полиморфными объекты тех классов, у которых применяется наследование и виртуальные методы. То есть полиморфный функциональный объект, это что-то типа:
```
struct Base
{
int operator()(int) const
{
method();
return 42;
}
virtual void method() const { std::cout << "Base class called.\n"; }
};
```
Данный функциональный объект не делает ничего полезного, но это даже хорошо, ведь реализация его методов не будет отвлекать нас от основной задачи — передать его наследника в алгоритм STL. А наследник будет переопределять виртуальный метод:
```
struct Derived : public Base
{
void method() const override { std::cout << "Derived class called.\n"; }
};
```
Давайте попробуем передать наследника в STL-алгоритм тривиальным способом, вот так:
```
void f(Base const& base)
{
std::vector v = {1, 2, 3};
std::transform(begin(v), end(v), begin(v), base);
}
int main()
{
Derived d;
f(d);
}
```
Что бы вы думали выведет этот код?
**Вот это**Base class called.
Base class called.
Base class called.
Странно, правда? Мы передали алгоритму объект класса Derived, с перегруженным виртуальным методом, но алгоритм решил вызвать вместо него метод базового класса. Чтобы понять, что произошло, давайте взглянем на прототип функции std::transform:
```
template< typename InputIterator, typename OutputIterator, typename Function>
OutputIt transform(InputIterator first, InputIterator last, OutputIterator out, Function f);
```
Посмотрите внимательно на её последний параметр (Function f) и обратите внимание, что он передаётся по значению. Как объясняется в главе 20 той же книги Effective C++, полиморфные объекты «срезаются», когда мы передаём их по значению: даже если ссылка на Base const& указывает на объект типа Derived, создание копии base создаёт объект типа Base, а не объект типа Derived.
Таким образом, нам нужен способ передать STL-алгоритму ссылку на полиморфный объект, а не на его копию.
Как это сделать?
### Давайте завернём наш объект в ещё один
Эта мысль вообще приходит первой: «Проблема? Давайте решим её с помощью добавления косвенности!» Если наш объект должен быть сначала передан по ссылке, а STL-алгоритм принимает лишь объекты по значению, то мы можем создать промежуточный объект, который будет хранить ссылку на нужный нам полиморфный объект, а вот сам этот объект уже может передаваться по значению.
Простейший путь сделать это — использовать лямбда-функцию:
```
std::transform(begin(v), end(v), begin(v), [&base](int n){ return base(n); }
```
Теперь код выводит следующее:
`Derived class called.
Derived class called.
Derived class called.`
Это работает, но обременяет код лямбда-функцией, которая хоть и достаточно коротка, но всё-же написана не для изящества кода, а лишь по техническим причинам.
Кроме того, в реальном коде она может выглядеть куда длиннее:
```
std::transform(begin(v), end(v), begin(v), [&base](module::domain::component myObject){ return base(myObject); }
```
Избыточный код, использующий функциональную парадигму в качестве костыля.
### Компактное решение: использовать std::ref
Есть и другой способ передачи полиморфного объекта по значению и заключается он в использовании std::ref
```
std::transform(begin(v), end(v), begin(v), std::ref(base));
```
Эффект будет такой же, как и от лямбда-функции:
`Derived class called.
Derived class called.
Derived class called.`
Возможно, сейчас у вас возникает вопрос «А почему?». У меня, например, он возник. Во-первых, как это вообще скомпилировалось? std::ref возвращает объект типа std::reference\_wrapper, который моделирует ссылку (с тем лишь исключением, что ей можно переприсвоить другой объект с помощью использования operator=). Как же std::reference\_wrapper может играть роль функционального объекта? Я посмотрел документацию по std::reference\_wrapper на [cppreference.com](http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper/operator()) и нашел вот это:
> std::reference\_wrapper::operator()
>
>
>
> Calls the Callable object, reference to which is stored. This function is available only if the stored reference points to a Callable object.
То есть это такая специальная фича в std::reference\_wrapper: если std::ref принимает функциональный объект типа F, то возвращаемый объект-имитатор ссылки тоже будет функционального типа и его operator() будет вызывать operator() типа F. В точности то, что нам и было необходимо.
Мне данное решение кажется лучшим, чем использование лямбда-функций, ведь тот же результат достигается более простым и лаконичным кодом. Возможно, существуют и другие решения данной проблемы — буду рад увидеть их в комментариях. | https://habr.com/ru/post/354198/ | null | ru | null |
# Возвращение в строй маршрутизатора Cisco с нерабочей CF или mini-flash картой
Как-то электрикам потребовалось провести плановые работы с отключением оборудования организации. По плану на ночь сотрудники выключают оборудование, электрики ночью работают, а утром сотрудники всё включают и радуются. Вечером отключили сервера, сетевое оборудование и ИБП. Утром всё включили и начали спокойно работать ровно до того момента, пока не поняли, что не поднялось подключение к сети интернет, а следовательно сайт организации снаружи недоступен.
*(Cisco 1800 series)*
**Почему вспомнил**Вспомнил об этом случае из-за того, что похожая ситуация произошла на днях с тестовым маршрутизатором Cisco 871-K9.
*(в этой модели модуль памяти mini-flash cisco слева внизу)*
Проверяем доступность маршрутизатора, пингуем. Маршрутизатор недоступен. Бежим смотреть на него в серверную и видим, что статусный светодиод в порядке. Значит надо подключаться к консоли.
Выкручивать маршрутизатор из серверного шкафа не хотелось, поэтому бросили 15-20 метров витой пары от серверной до нашего кабинета в качестве удлинителя для консольного провода.
**Проверяем**Берём пару патчкордов, консольный кабель cisco и соединяем всё это добро парой переходников.
*(длина двух патчкордов с переходником ~18.3м)*
Работает.
Подключились и видим приглашение `**rommon 1 >**` Значит маршрутизатор не смог найти или загрузить прошивку. К этому мы оказались не готовы и полезли искать подходящую, а вот копия конфигурации маршрутизатора нашлась.
Сначала попробовали залить прошивку через **xmodem**, но скорости нас не впечатлили настолько, что сразу перешли к загрузке прошивки через tftp. На компьютере в сети был поставлен tftpd и файл прошивки маршрутизатора (в данном примере пусть адрес этого компьютера будет 192.168.1.2). На маршрутизаторе через консоль дали следующие команды:
`**IP\_ADDRESS=192.168.1.200
IP\_SUBNET\_MASK=255.255.255.0
DEFAULT\_GATEWAY=192.168.1.1
TFTP\_SERVER=192.168.1.2
TFTP\_FILE=c870-advipservicesk9-mz.124-24.T8.bin**`
*(в названии файла прошивки я указал прошивку нашего тестового маршрутизатора, т.к. проверял всё на нём)*
И даём команду `**tftpdnld -r**` (ключ **-r** важен в том случае, если карта памяти не работает ~~или её унесли какие-то несознательные типы~~, т.к. позволяет нам загрузить файл прошивки сразу в оперативную память маршрутизатора минуя карту памяти).
Если и файл стартовой конфигурации (startup-config) был на той же карте памяти, то следующим шагом заливаем сохранённую у нас конфигурацию через tftp. Или настраиваем маршрутизатор заново из консоли.
`**Router#copy tftp: running-config**`
*(на всякий случай отмечу, что Router# — это уже приглашение IOS, т.к. система должна была загрузиться)*
Нам предложат указать адрес хоста tftp, имя файла источника и подтвердить имя файла назначения.
Маршрутизатор заработал как положено, мы отключили импровизированный консольный патчкорд и пошли не спеша искать подходящую карту памяти. | https://habr.com/ru/post/335648/ | null | ru | null |
# Unity: 8 причин отказаться от Coroutine в пользу Async
Введение
--------
Когда речь заходит об асинхронных операциях в Unity, на ум первым делом приходит coroutine. И это не удивительно, так как большинство примеров в сети реализованы именно через них. Но мало кто знает, что Unity поддерживает работу с async/await еще с 2017 версии.
Так почему же большинство разработчиков до сих пор использует coroutine вместо async/await? Во первых, как я уже упомянул, большая часть примеров написана с использованием coroutine. Во вторых, async/await кажется очень сложным для начинающих разработчиков. Ну и в третьих, когда речь заходит о коммерческих проектах, где основным из критериев является стабильность, предпочтение отдается проверенному годами подходу.
Но технологии не стоят на месте и появляются библиотеки, которые делают работу с async/await в Unity удобной, стабильной и самое главное высокопроизводительной. И говорю я о библиотеке [UniTask](https://github.com/Cysharp/UniTask).
Я не буду перечислять все преимущества этой библиотеки, а выделю только основные:
* Использует структуры для задач и кастомный AsyncMethodBuilder для достижения zero allocation
* Позволяет использовать ключевое слово await со всеми Unity AsyncOperations и Coroutine
* Не использует потоки и полностью работает на Unity PlayerLoop, что позволяет использовать async/await в WebGL, Wasm и т.д.
Сразу скажу, что статья не создана с целью заставить вас переписать текущие проекты, а лишь перечисляет причины, которые могут сыграть ключевую роль при выборе подхода, для реализации будущих.
P.S. Код из последующих пунктов, приведен в качестве примера и может содержать ошибки. Не копируйте его бездумно в свой продукт.
1. Has return value
-------------------
Coroutine не могут возвращать значения. Поэтому, если необходимо получить результат из метода, используется callback типа Action, либо приведение IEnumerator.Current к необходимому типу, после завершения coroutine, но эти подходы, как минимум, неудобны в использовании и подвержены ошибкам.
Давайте разберем пример, в котором необходимо загрузить изображение из сети, и вернуть его как результат выполнения метода.
С использованием coroutine подобное можно реализовать так:
```
private IEnumerator Start()
{
yield return DownloadImageCoroutine(_imageUrl, texture =>
{
_image.texture = texture;
});
}
private IEnumerator DownloadImageCoroutine(string imageUrl,
Action callback)
{
using var request = UnityWebRequestTexture.GetTexture(imageUrl);
yield return request.SendWebRequest();
callback?.Invoke(request.result == UnityWebRequest.Result.Success
? DownloadHandlerTexture.GetContent(request)
: null);
}
```
То же самое с использованием async/await делается вот так:
```
private async void Start()
{
_image.texture = await DownloadImageAsync(_imageUrl);
}
private async UniTask DownloadImageAsync(string imageUrl)
{
using var request = UnityWebRequestTexture.GetTexture(imageUrl);
await request.SendWebRequest();
return request.result == UnityWebRequest.Result.Success
? DownloadHandlerTexture.GetContent(request)
: null;
}
```
В реализации через async/await нет необходимости использовать callback и такой код читается легче. Так что если вы устали от постоянных callback’ов, то async/await ваш выбор.
2. Parallel processing
----------------------
А теперь представим, что необходимо загрузить n изображений, и сделать это параллельно.
Решить подобную задачу с помощью coroutine можно так:
```
private IEnumerator Start()
{
var textures = new List();
yield return WhenAll(\_imageUrls.Select(imageUrl =>
{
return DownloadImageCoroutine(imageUrl, texture =>
{
textures.Add(texture);
});
}));
for (var i = 0; i < textures.Count; i++)
{
\_images[i].texture = textures[i];
}
}
private IEnumerator WhenAll(IEnumerable routines)
{
var startedCoroutines = routines.Select(StartCoroutine).ToArray();
foreach (var startedCoroutine in startedCoroutines)
{
yield return startedCoroutine;
}
}
```
Вот то же самое, реализованное с использованием async/await:
```
private async void Start()
{
var textures =
await UniTask.WhenAll(_imageUrls.Select(DownloadImageAsync));
for (var i = 0; i < textures.Length; i++)
{
_images[i].texture = textures[i];
}
}
```
Из приведенных примеров видно, что используя coroutine необходимо самостоятельно реализовать метод WhenAll, в то время как UniTask предоставляет его из коробки, так же как и метод WhenAny. Попробуйте, на досуге, реализовать WhenAny используя coroutine, удивитесь как быстро возрастет сложность исходного кода.
3. Supports try/catch
---------------------
Следующим преимуществом async/await перед coroutine является поддержка блока try/catch. Следовательно обернув наш код в try/catch, мы можем поймать и обработать ошибку в одном месте, где бы в стеке вызовов она не возникла. При попытке же обернуть yield return, компилятор выдаст ошибку.
Нельзя обернуть yield return в блок try/catch:
```
private IEnumerator Start()
{
try
{
yield return ConstructScene(); // Compiler error!
}
catch (Exception exception)
{
Debug.LogError(exception.Message);
throw;
}
}
```
Используя async/await такой проблемы нет:
```
private async void Start()
{
try
{
await ConstructScene();
}
catch (Exception exception)
{
Debug.LogError(exception.Message);
throw;
}
}
```
4. Always exits
---------------
В дополнение к предыдущему пункту, давайте посмотрим на блок try/finally.
Реализация используя coroutine:
```
private IEnumerator ShowEffectCoroutine(RawImage container)
{
var texture = new RenderTexture(256, 256, 0);
try
{
container.texture = texture;
for (var i = 0; i < _frameCount; i++)
{
/*
* Update effect.
*/
yield return null;
}
}
finally
{
texture.Release();
}
}
```
Реализация используя async/await:
```
private async UniTask ShowEffectAsync(RawImage container)
{
var texture = new RenderTexture(256, 256, 0);
try
{
container.texture = texture;
for (var i = 0; i < _frameCount; i++)
{
/*
* Update effect.
*/
await UniTask.Yield();
}
}
finally
{
texture.Release();
}
}
```
Приведенные примеры реализуют абсолютно одинаковую логику. Но в случае с coroutine, при ее остановке, возникновении исключения или удалении объекта на котором она была запущена, блок finally не будет достигнут. В реализации с использованием async/await такой проблемы нет и блок finally выполнится в любом случае, как от него и ожидается. Так что если у вас есть код использующий coroutine и блок try/finally, обратите на него внимание, возможно, у вас там утечка памяти.
5. Lifetime handled manually
----------------------------
Еще одним преимуществом async/await над coroutine является то, что для запуска асинхронной операции не нужен MonoBehaviour и вы сами контролируете ее жизненный цикл. Нет больше необходимости держать MonoBehaviour класс на сцене, единственной задачей которого является обеспечение работы запущенных coroutine.
Но с большими возможностями приходит и большая ответственность. Давайте посмотрим на следующий пример.
Реализация на coroutine:
```
private IEnumerator Start()
{
StartCoroutine(RotateCoroutine());
yield return new WaitForSeconds(1.0f);
Destroy(gameObject);
}
private IEnumerator RotateCoroutine()
{
while (true)
{
transform.Rotate(Vector3.up, 1.0f);
yield return null;
}
}
```
Реализация на async/await:
```
private async void Start()
{
RotateAsync().Forget();
await UniTask.Delay(1000);
Destroy(gameObject);
}
private async UniTaskVoid RotateAsync()
{
while (true)
{
transform.Rotate(Vector3.up, 1.0f);
await UniTask.Yield();
}
}
```
Как упоминалось выше, жизненный цикл async метода не зависит от MonoBehaviour. Следовательно после уничтожения объекта, в методе RotateAsync возникнет исключение MissingReferenceException, так как он продолжит выполняться, в то время как transform объекта, к которому мы обращаемся, уже не будет существовать. В случае же с coroutine, выполнение метода RotateCoroutine автоматически прекратиться, так как при удалении MonoBehaviour, все coroutine запущенные на нем останавливаются.
На самом деле, есть два подхода для решения этой задачи. Первый, остановить выполнение async метода передав в него CancellationToken, этот вариант подробнее разберем далее. Второй, самый логичный и правильный, просто вынести логику которая должна выполняться на каждом кадре, в Update. Зачем нам накладные расходы с созданием и поддержанием работы дополнительных объектов?
6. Full control
---------------
Как было сказано выше, так как жизненный цикл async метода не зависит от MonoBehaviour, у нас есть полный контроль над запущенной операцией. Чего нельзя сказать о coroutine.
Давайте разберем пример с реализацией механизма отмены асинхронной операции. Опустим все проверки и сконцентрируемся только на основной логике.
Используя coroutine, отмену обычно реализуют так:
```
public void StartOperation()
{
_downloadCoroutine =
StartCoroutine(DownloadImageCoroutine(_imageUrl, texture =>
{
_image.texture = texture;
}));
}
public void CancelOperation()
{
StopCoroutine(_downloadCoroutine);
}
private IEnumerator DownloadImageCoroutine(string imageUrl,
Action callback)
{
var request = UnityWebRequestTexture.GetTexture(imageUrl);
try
{
yield return request.SendWebRequest();
callback?.Invoke(
request.result == UnityWebRequest.Result.Success
? DownloadHandlerTexture.GetContent(request)
: null);
}
finally
{
request.Dispose();
}
}
```
Но внимательный читатель уже заметил проблему. Если у нас где-то в середине загрузки произойдет отмена операции, то блок finally не будет достигнут и Dispose не вызовется. Как же быть в данной ситуации?
Здесь на помощь может прийти CancellationToken:
```
public void StartOperation(CancellationToken token = default)
{
StartCoroutine(DownloadImageCoroutine(_imageUrl, texture =>
{
_image.texture = texture;
}, token));
}
private IEnumerator DownloadImageCoroutine(string imageUrl,
Action callback, CancellationToken token)
{
var request = UnityWebRequestTexture.GetTexture(imageUrl);
try
{
var asyncOperation = request.SendWebRequest();
while (asyncOperation.isDone == false)
{
if (token.IsCancellationRequested)
{
request.Abort();
yield break;
}
yield return null;
}
callback?.Invoke(
request.result == UnityWebRequest.Result.Success
? DownloadHandlerTexture.GetContent(request)
: null);
}
finally
{
request.Dispose();
}
}
```
Уже лучше, теперь при отмене операции блок finally будет выполнен. Но мы все равно не застрахованы от деактивации объекта или удаления MonoBehaviour. Вот и получается, что над coroutine у нас нет полного контроля. В реализации же через async/await такой проблемы нет.
Реализация на async/await используя CancellationToken:
```
public async UniTaskVoid StartOperation(CancellationToken token = default)
{
_image.texture = await DownloadImageAsync(_imageUrl, token);
}
private async UniTask DownloadImageAsync(string imageUrl,
CancellationToken token)
{
var request = UnityWebRequestTexture.GetTexture(imageUrl);
try
{
await request.SendWebRequest().WithCancellation(token);
return request.result == UnityWebRequest.Result.Success
? DownloadHandlerTexture.GetContent(request)
: null;
}
finally
{
request.Dispose();
}
}
```
Вообще передача CancellationToken в асинхронный метод, является хорошей практикой, и желательно предусмотреть его использование в этих методах.
7. Preserves call stack
-----------------------
Давайте взглянем на предоставляемый стек вызовов при возникновении ошибки.
Стек вызовов при возникновении ошибки в coroutine:
Стек вызовов при возникновении ошибки в coroutineСтек вызовов при возникновении ошибки в async методе:
Стек вызовов при возникновении ошибки в async методеВ случае с coroutine мы видим, что ошибка произошла в методе CreatePlayer, но непонятно, кто вызвал этот метод. Хорошо, если метод CreatePlayer вызывается только в одном месте, тогда проследить всю цепочку вызовов не составит труда, а если он вызывается из нескольких мест? В случае с async/await мы сразу видим всю цепочку вызовов, где у нас потенциально может быть проблема, что здорово экономит время при поиске ошибок.
8. Allocation & Performance
---------------------------
Ну и последний в списке, но не последний по значимости, пункт про производительность и использование памяти. Как уже упоминалось выше, UniTask использует структуры для задач и кастомный AsyncMethodBuilder, для достижения zero allocation. Также UniTask не использует ExecutionContext и SynchronizationContext, в отличии от Task, что позволяет добиться высокой производительности в Unity, так как исключает накладные расходы на переключение контекстов.
Я не буду здесь углубляться во все тонкости касательно производительности и использования памяти, для этого лучше почитать статью от самого автора [вот тут](https://neuecc.medium.com/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd), а приведу только результаты тестирования.
Выделение памяти при использовании UniTask, Coroutine и TaskТак как тестирование производилось в редакторе Unity, AsyncStateMachine генерируемая комплятором C# это класс, поэтому мы видим выделения памяти при использовании UniTask. В релизном билде, AsyncStateMachine будет структурой и память выделяться не будет. Но даже несмотря на это, UniTask выделяет памяти существенно меньше чем Coroutine и Task.
Репозиторий с тестами производительности можно найти [тут](https://github.com/JoaoBorks/unity-async-vs-coroutine). Убедитесь только, что используется последняя версия UniTask.
Заключение
----------
Надеюсь перечисленных пунктов достаточно, чтобы вы посмотрели на использование async/await в Unity по новому, и начали рассматривать как альтернативу coroutine.
Пример использования библиотеки UniTask в проекте, можно найти [здесь](https://github.com/ChebanovDD/Meetups/tree/main/Game%20DevPRO%202021). Там же можно найти список источников, который поможет составить полную картину того, как работает async/await в C#.
Я сейчас готовлю статью о самых распространенных ошибках при использовании async/await, так что если интересно подробнее разобраться в этой теме, следите за обновлениями.
P.S. Буду рад любым комментариям, дополнениям и конструктивной критике. | https://habr.com/ru/post/652483/ | null | ru | null |
# Cacheops
Некоторое время назад [я писал о системе кеширования](http://habrahabr.ru/blogs/algorithm/120471/). Помнится, я обещал продолжение, но сейчас решил, что строка кода лучше сотни комментариев, теорию оставим на потом. Поэтому сегодня у нас своего рода анонс с парой советов по использованию в одном флаконе. Встречайте, cacheops — система кеширования и автоматической инвалидации кеша для Django ORM.
Краткие разъяснения для тех, кто не читал или просто подзабыл предыдущую статью. Система призвана инвалидировать результаты запросов к базе через ORM по событию изменения объекта модели, автоматически определяя для каждого события результаты каких запросов могли устареть. Так как для автоматической инвалидации требуется хранить дополнительную структурированную информацию кроме, собственно, содержимого кеша, то в качестве бэкенда был выбран [Redis](http://redis.io/). А так как это практический анонс, то я затыкаюсь и перехожу к делу.
Положим вы уже установили сам Redis, Django и у вас есть что-то, что можно кешировать (модели и запросы с их использованием). Установим cacheops:
```
pip install django-cacheops
```
или если вы всё же решите покопаться в коде:
```
git clone git://github.com/Suor/django-cacheops.git
ln -s `pwd`/django-cacheops/cacheops/ /somewhere/on/your/python/import/path/
```
Далее нам следует его настроить, добавим cacheops в список установленных приложений. Cacheops должен быть инициализирован до загрузки моделей Django, поэтому ставим его первым:
```
INSTALLED_APPS = (
'cacheops',
...
)
```
Необходимо также настроить соединение с редисом и профили кеширования:
```
CACHEOPS_REDIS = {
'host': 'localhost', # сервер redis доступен локально
'port': 6379, # порт по умолчанию
#'db': 1, # можно выбрать номер БД
'socket_timeout': 3,
}
CACHEOPS = {
# Автоматически кешировать все User.objects.get() на 15 минут
# В том числе доступ через request.user и post.author,
# где Post.author - foreign key к auth.User
'auth.user': ('get', 60*15),
# Автоматически кешировать все запросы
# к остальным моделям django.contrib.auth на час
'auth.*': ('all', 60*60),
# Включить ручное кеширование для всех моделей приложения news на час.
# Инвалидация по-прежнему автоматическая.
'news.*': ('just_enable', 60*60),
# Автоматически кешировать все запросы .count()
# для оставшихся моделей на 15 минут
'*.*': ('count', 60*15),
}
```
Здесь и далее часто фигурирует время хранения кеша, важно понимать, что это только максимальное ограничение на время жизни, в реальной работе каждая конкретная запись может быть стёрта значительно раньше по событию.
Настройка готова, можно приступать. Собственно, можно уже пользоваться, все запросы указанных типов будут кешироваться и автоматически инвалидироваться при изменении, добавлении или удалении соответствующих моделей. Однако, возможно и более тонкое использование, на уровне отдельных queryset-ов.
В качестве минимальной настройки, которая позволит использовать ручное кеширование, можно использовать:
```
CACHEOPS = {
'*.*': ('just_enable', <таймаут по умолчанию>),
}
```
Это позволит нам писать что-то вроде:
```
articles = Article.objects.filter(tag=2).cache()
```
и получить запрос к базе, который с одной стороны будет закеширован, а с другой, кеш которого будет стёрт, при изменении, добавлении или удалении статьи с тегом 2.
В метод .cache() можно передать набор операций, который нужно кешировать и таймаут:
```
qs = Article.objects.filter(tag=2).cache(ops=['count'], timeout=60*5)
paginator = Paginator(objects, ipp) # count запрос внутри будет кеширован на 5 минут
artiсles = list(pager.page(page_num)) # а эта выборка кеширована не будет
```
Набор операций может быть любым подмножеством ['get', 'fetch', 'count'], в том числе пустым — чтобы отключить кеширование для текущего queryset-а. Впрочем, для последнего случая есть шорткат:
```
qs = Article.objects.filter(visible=True).nocache()
```
Здесь доступ к содержимому qs пойдёт в базу.
Кроме queryset-ов cacheops умеет работать с функциями, причём может инвалидировать их как некоторый queryset:
```
from cacheops import cacheoped_as
@cacheoped_as(Article.objects.all())
def article_stats():
return {
'tags': list( Article.objects.values('tag').annotate(count=Count('id')).nocache() )
'categories': list( Article.objects.values('category').annotate(count=Count('id')).nocache() )
}
```
Обратите внимание на оборачивание queryset-ов в list() — мы же не хотим положить в кеш объект запроса, который потом будет выполнятся каждый раз при попытке доступа. Также мы используем .nocache(), чтобы не делать лишней работы и не засорять кеш промежуточными результатами.
Пожалуй, я дал достаточно, чтобы желающие могли почувствовать вкус, так что остановлюсь, пока это не стало скучным.
**P.S.** Для тех, кто хочет интимных подробностей — на гитхабе есть [ветка с русскими комментариями](https://github.com/Suor/django-cacheops/tree/ru_comments/cacheops). | https://habr.com/ru/post/129122/ | null | ru | null |
# История про хитрожо… индуса, encrypted procedures, DAC и «режим Бога»
На той неделе пришлось разбираться в логике работы одного бесплатного тула. Почти детективная история вышла с ее автором, который впоследствии оказался индусом канадского происхождения проживающим в Южной Америке.
Конечно же, практическая ценность была не в биографии автора, а в запросах, которые отправлялись приложением на сервер.
Установил. Запустил. Стал в стоечку и начал собирать профайлером все, чем приложение должно было «порадовать» сервер. Смею разочаровать – ничего радостного сервер в ближайшие два часа не увидел. В основном встречались разного рода перлы в запросах, которые явно не претендовали на комплименты:
```
SELECT
LogTruncations = (
SELECT TOP 1 SUM(cntr_value)
FROM ##tbl_cnt
WHERE counter_name = 'Log Truncations'
),
LogShrinks = (
SELECT TOP 1 SUM(cntr_value)
FROM ##tbl_cnt
WHERE counter_name = 'Log Shrinks'
),
LogGrowths = (
SELECT TOP 1 SUM(cntr_value)
FROM ##tbl_cnt
WHERE counter_name = 'Log Growths'
),
...
```
Поскольку их можно написать на порядок проще и сократить логические чтения из таблицы:
```
SELECT
LogTruncations = SUM(CASE WHEN counter_name = 'Log Truncations' THEN cntr_value END),
LogShrinks = SUM(CASE WHEN counter_name = 'Log Shrinks' THEN cntr_value END),
LogGrowths = SUM(CASE WHEN counter_name = 'Log Growths' THEN cntr_value END),
...
FROM ##tbl_cnt
```
На этом можно было бы и закончить… Но практически под конец я увидел, что приложение вызывает пользовательские хранимые процедуры из *tempdb*. Поймал себя на мысли: «Когда приложение успело их создать… и главное зачем?»
Оказывается, инсталлятор по-тихому нашел дефолтный экземпляр *SQL Server* на моей локальной машине и создал там хранимки. Попробовал поработать с данным тулом на именованном инстансе… *Error Message*!
Архитектурное решение на грани фантастики. К слову скажу, при каждом рестарте сервера база *tempdb* пересоздаётся… так что ж мне программу каждый раз переустанавливать? Бред! Бред… как сказал бы мой попугай.
Оки… Развернем эти хранимки на именованном сервере, а заодно посмотрим, что в них такого ценного. Открываем хранимые процедуры в *Database Explorer* и видим «картину маслом»:
Замочек на объектах… а значит хранимые процедуры созданы с параметром *WITH ENCRYPTION* и сгенерировать в *SSMS* команду *CREATE* или *ALTER* уже не получится:
*Property TextHeader is not available for StoredProcedure '[dbo].[shb\_get\_waitstats']'. This property may not exist for this object, or may not be retrievable due to insufficient access rights. The text is encrypted.*
В метаданных мы тоже не сможем получить сорс зашифрованных объектов:
```
SELECT o.name, s.[definition]
FROM sys.objects o
JOIN sys.sql_modules s ON o.[object_id] = s.[object_id]
WHERE [type] = 'P'
```
```
name definition
------------------------- ------------
shb_generate_waitstats NULL
shb_get_waitstats NULL
shb_get_waitstats_all NULL
shb_avg_waiting_task NULL
shb_expensiveqry NULL
shb_get_querystats NULL
shb_agent_log NULL
shb_error_log NULL
shb_default_trace NULL
shb_spConfigure NULL
```
Такой ~~лайвфак~~ лайвхак также не сработает:
```
SELECT OBJECT_DEFINITION(OBJECT_ID('dbo.shb_get_waitstats'))
```
Переустанавливать приложение не хотелось и поэтому решил схитрить. Включаем «режим Бога», который разрешает подключаться к серверу через *DAC* (*Dedicated Administrator Connection*):
```
EXEC sys.sp_configure 'show advanced options', 1
RECONFIGURE WITH OVERRIDE
GO
EXEC sys.sp_configure 'remote admin connections', 1
RECONFIGURE WITH OVERRIDE
GO
```
Вначале соединения в *SQL* документе дописываем *ADMIN:* и проверяем что пользователь под которым мы коннектимся является *sysadmin*-ом:
Если соединение пройдет успешно, то мы будем имеем абсолютную власть на сервером. Но что на практике поменяется? Ведь мы и так имеем права *sysadmin*, которые разрешают все что только можно.
Как оказывается, ограничение все же есть. Пробовали ли хоть раз читать из системных таблиц? В *SQL Server 2000* такое поведение разрешалось. С приходом же *2005* версии секьюрность метаданных претерпела существенные изменения и доступа к системных таблицам напрямую теперь уже нет.
В основном к таблицам с метаданными можно обращаться неявно, посредством системных представлений, которых в 99% случаев бывает достаточно. Но не в нашем случае. Существует отдельная таблица *sys.sysobjvalues* в которой хранятся зашифрованные объекты:
```
SELECT * FROM sys.sysobjvalues
```
В обычных условиях читать из нее нельзя:
```
Msg 208, Level 16, State 1, Line 1
Invalid object name 'sys.sysobjvalues'.
```
но при подключении через *DAC* становится возможным выборка из любой системной таблицы и из нее в частности:
```
SELECT *
FROM sys.sysobjvalues
WHERE [objid] = OBJECT_ID('[dbo].[shb_get_waitstats]')
```
```
valclass objid subobjid valnum value imageval
-------- ----------- ----------- ----------- --------- --------------------------------
1 1429580131 1 0 0 0x037112F3D7F8C09E11A1A8FB....
```
Имея на руках зашифрованное тело хранимой процедуры можно ее расшифровать…
Для начала мы получаем бинарное представление хранимки в зашифрованном виде. Создаем заготовку хранимки с идентичным именем и параметром *WITH ENCRYPTION*, но вместо тела подставляем символы дефисов:
```
DECLARE
@obj SYSNAME = '[dbo].[shb_get_waitstats]'
, @enc NVARCHAR(MAX)
, @enc_length INT
, @obj_type NVARCHAR(100)
, @obj_name SYSNAME
SELECT
@enc = imageval
, @enc_length = (DATALENGTH(imageval) / 2) + 1
, @obj_name = QUOTENAME(SCHEMA_NAME(o.[schema_id])) + N'.' + QUOTENAME(o.name)
FROM sys.sysobjvalues v
JOIN sys.objects o ON v.[objid] = o.[object_id]
WHERE [objid] = OBJECT_ID(@obj, 'P')
AND imageval IS NOT NULL
DECLARE @header NVARCHAR(MAX)
SET @header = N'ALTER PROCEDURE ' + @obj_name + N' WITH ENCRYPTION AS '
SET @header = @header + REPLICATE(CAST('-' AS NVARCHAR(MAX)), (@enc_length - LEN(@header)))
DECLARE @tmp TABLE (enc NVARCHAR(MAX))
BEGIN TRANSACTION
EXEC sys.sp_executesql @header
INSERT INTO @tmp (enc)
SELECT imageval
FROM sys.sysobjvalues
WHERE [objid] = OBJECT_ID(@obj)
ROLLBACK TRANSACTION
DECLARE @blank_enc NVARCHAR(MAX)
SELECT @blank_enc = enc
FROM @tmp
SET @header = N'CREATE PROCEDURE ' + @obj_name + N' WITH ENCRYPTION AS '
SET @header = @header + REPLICATE(CAST('-' AS NVARCHAR(MAX)), (@enc_length - LEN(@header)))
;WITH
E1(N) AS (
SELECT * FROM (
VALUES
(1),(1),(1),(1),(1),
(1),(1),(1),(1),(1)
) t(N)
),
E2(N) AS (SELECT 1 FROM E1 a, E1 b),
E4(N) AS (SELECT 1 FROM E2 a, E2 b),
E8(N) AS (SELECT 1 FROM E4 a, E4 b)
SELECT (
SELECT
NCHAR(
UNICODE(SUBSTRING(@enc, RowNum, 1)) ^
UNICODE(SUBSTRING(@header, RowNum, 1)) ^
UNICODE(SUBSTRING(@blank_enc, RowNum, 1))
)
FROM (
SELECT TOP(@enc_length) RowNum = ROW_NUMBER() OVER (ORDER BY 1/0)
FROM E8
) t
FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)')
```
Далее используя *XOR* преобразование над полученными строками, мы можем расшифровать требуемый объект:
```
CREATE PROCEDURE shb_get_waitstats
WITH ENCRYPTION
AS
BEGIN
SET NOCOUNT ON;
EXEC shb_generate_waitstats
SELECT DISTINCT
GETDATE() AS collection_time,
a.category_name AS [Wait Category] ,
ISNULL(dt.[Wait Time (ms/sec)], 0) [Wait Time (ms/sec)] ,
ISNULL(dt.[Recent Wait Time (ms/sec)], 0) [Recent Wait Time (ms/sec)] ,
ISNULL(dt.[Average Waiter Count], 0) [Average Waiter Count] ,
ISNULL(dt.[Cumulative Wait Time], 0) [Cumulative Wait Time] ,
ISNULL(dt.[avg_waiting_task_count], 0) AS [Avg Waiting Task]
FROM #am_wait_types a
LEFT JOIN ( SELECT category_name ,
SUM(interval_wait_time_per_sec) AS [Wait Time (ms/sec)] ,
SUM(weighted_average_wait_time_per_sec) AS [Recent Wait Time (ms/sec)] ,
SUM(interval_avg_waiter_count) AS [Average Waiter Count] ,
SUM(resource_wait_time_cumulative) AS [Cumulative Wait Time] ,
SUM(interval_wait_time_per_sec) / 1000 AS avg_waiting_task_count
FROM #am_resource_mon_snap
GROUP BY category_name
) dt ON a.category_name = dt.[category_name]
END
```
Можно легко проверить все на простом примере:
```
IF OBJECT_ID('dbo.test') IS NOT NULL
DROP PROCEDURE dbo.test
GO
CREATE PROCEDURE dbo.test (@a INT)
WITH ENCRYPTION
AS BEGIN
RETURN 123
END
GO
```
Все вроде кажется таким элементарным, но что если нет возможности подключиться через *DAC*? Или требуется расшифровать скалярную функцию или представление… Есть вариант использовать самописную *CLR* сборку, которую можно поискать на *CodeProject* или воспользоваться уже готовыми решениями.
К слову о последнем варианте… Уже давно существует бесплатный продукт – [*dbForge SQL Decryptor*](https://www.devart.com/dbforge/sql/sqldecryptor/), который позволяет в пакетном режиме расшифровывать все скриптовые объекты:
И что самое главное, для его работы не требуется *DAC* подключение. Мне стало очень интересно, как без использования *DAC* выбрать данные из системной таблицы… оказалось все очень просто. Вначале *SQL Decryptor* получает список страниц, на которых хранятся данные из *sys.sysobjvalues*:
```
DBCC TRACEON(3604)
DBCC IND (tempdb, [sys.sysobjvalues], 1) WITH TABLERESULTS, NO_INFOMSGS
DBCC TRACEOFF(3604)
```
Потом обходит все страницы:
```
DBCC TRACEON(3604)
DBCC PAGE (tempdb, 1, 128, 3)
DBCC PAGE (tempdb, 1, 132, 3)
DBCC PAGE (tempdb, 1, 132, 3)
DBCC PAGE (tempdb, 1, 138, 3)
DBCC PAGE (tempdb, 1, 23, 3)
DBCC TRACEOFF(3604)
```
Смотрит на их содержимое:
```
0000000053B5F8C0: 07000000 a209d600 ea9b0000 66000000 00000000 ....¢ Ö.ê..f.......
0000000053B5F8D4: 66000000 00000000 16c4643f 0317383c a1a0203c f........Äd?..81¡ 1
0000000053B5F8E8: a1a0203c a1a0203c a1a0203c 00000000 00000000 ¡ 1¡ 1¡ 1........
0000000053B5F8FC: 00000000 00000000 00000000 00000000 00000000 ....................
0000000053B5F910: 00000000 00000000 00000000 00000000 00000000 ....................
0000000053B5F924: 00000000 00000000 00000000 00000000 00000000 ....................
0000000053B5F938: 00000000 00000000 00000000 00000000 00000000 ....................
0000000053B5F94C: 00000000 00000000 00000000 00000000 00000000 ....................
0000000053B5F960: 00000000 2f000000 2f000000 05000000 14000000 ..../.../...........
0000000053B5F974: 00008841 0000cc42 00000000 00008040 0000803f ...A..ÌB......@..?
0000000053B5F988: 00008040 00008040 00008040 00000000 00000000 ..@..@..@........
0000000053B5F99C: 00000000 00000000 00000000 00000000 00000000 ....................
0000000053B5FA14: b1050000 00000000 78010000 00000000 8f010000 ±.......x..........
0000000053B5FA28: 00000000 a6010000 00000000 bd010000 00000000 ....¦.......½.......
0000000053B5FA3C: d4010000 00000000 eb010000 00000000 02020000 Ô.......ë...........
0000000053B5FA50: 00000000 19020000 00000000 30020000 00000000 ............0.......
0000000053B5FA64: 47020000 00000000 5e020000 00000000 75020000 G.......^.......u...
```
И по нему достает бинарное представление объектов в зашифрованном виде. А дальше Вы уже знаете, как происходит – простое *XOR* преобразование.
**Краткие выводы:**
Что сказать по данному поводу? Если Вам нужно автоматизировать процесс расшифровки объектов, то можно написать скрипт по аналогии с моим решением. Но в большинстве случаев будет достаточно просто запустить [*dbForge SQL Decryptor*](https://www.devart.com/dbforge/sql/sqldecryptor/), выбрать объект и получить его сорс:
После этого *CodeReview* я пообщался с индусом. Он выслушал все мои замечания по части найденных проблем с запросами и больше уже больше не выходил на связь… Вот такая выдалась продуктивная неделя.
Если хотите поделиться этой статьей с англоязычной аудиторией:
[The Tale of the Cunning Dev, Encrypted Procedures, DAC and God Mode = ON](http://blog.sqlauthority.com/2016/04/22/tale-cunning-dev-encrypted-procedures-dac-god-mode-experts-opinion/) | https://habr.com/ru/post/278737/ | null | ru | null |
# Наивный Байес, или о том, как математика позволяет фильтровать спам
Привет! В этой статье я расскажу про байесовский классификатор, как один из вариантов фильтрации спам-писем. Пройдемся по теории, затем закрепим практикой, ну и в конце предоставлю свой набросок кода на мною обожаемом языке R. Буду стараться излагать максимально легкими выражениями и формулировками. Приступим!
### Без формул никуда, ну и краткая теория
Байесовский классификатор относится к разряду машинного обучения. Суть такова: система, перед которой стоит задача определить, является ли следующее письмо спамом, заранее обучена каким-то количеством писем точно известных где «спам», а где «не спам». Уже стало понятно, что это обучение с учителем, где в роли учителя выступаем мы. Байесовский классификатор представляет документ (в нашем случае письмо) в виде набора слов, которые якобы не зависят друг от друга (вот от сюда и вытекает та самая наивность).
Необходимо рассчитать оценку для каждого класса (спам/не спам) и выбрать ту, которая получилась максимальной. Для этого используем следующую формулу:
![$arg\max[P(Q_k)\prod_{i=1}^nP(x_i|Q_k)]$](https://habrastorage.org/getpro/habr/formulas/ef5/da8/cf8/ef5da8cf89c8ecaa0536f61a2c942f89.svg)
 — вхождение слова  в документ класса  (со сглаживанием)\*
 — количество слов входящих в документ класса 
М — количество слов из обучающей выборки
 — количество вхождений слова  в документ класса 
 — параметр для сглаживания
Когда объем текста очень большой, приходится работать с очень маленькими числами. Для того чтобы этого избежать, можно преобразовать формулу по свойству логарифма\*\*:
Подставляем и получаем:
![$arg\max[\log{P(Q_k)}+\sum_{i=1}^n\log{P(x_i|Q_k)}]$](https://habrastorage.org/getpro/habr/formulas/ae6/1e5/414/ae61e54141d284c759854dbafb17e79e.svg)
\*Во время выполнения подсчетов вам может встретиться слово, которого не было на этапе обучения системы. Это может привести к тому, что оценка будет равна нулю и документ нельзя будет отнести ни в одну из категорий (спам/не спам). Как бы вы не хотели, вы не обучите свою систему всем возможным словам. Для этого необходимо применить сглаживание, а точнее – сделать небольшие поправки во все вероятности вхождения слов в документ. Выбирается параметр 0<α≤1 (если α=1, то это сглаживание Лапласа)
\*\*Логарифм – монотонно возрастающая функция. Как видно из первой формулы – мы ищем максимум. Логарифм от функции достигнет максимума в той же точке (по оси абсцисс), что и сама функция. Это упрощает вычисление, ибо меняется только численное значение.
### От теории к практике
Пусть наша система обучалась на следующих письмам, заранее известных где «спам», а где «не спам» (обучающая выборка):
**Спам:**
* «Путевки по низкой цене»
* «Акция! Купи шоколадку и получи телефон в подарок»
**Не спам:**
* «Завтра состоится собрание»
* «Купи килограмм яблок и шоколадку»
**Задание:** определить, к какой категории отнести следующее письмо:
* «В магазине гора яблок. Купи семь килограмм и шоколадку»
**Решение:**
Составляем таблицу. Убираем все «стоп-слова», рассчитываем вероятности, параметр для сглаживания принимаем за единицу.
Оценка для категории «Спам»:
Оценка для категории «Не спам»:
**Ответ:** оценка «Не спам» больше оценки «Спам». Значит проверочное письмо — не спам!
То же самое рассчитаем и с помощью функции, преобразованной по свойству логарифма:
Оценка для категории «Спам»:
Оценка для категории «Не спам»:
**Ответ:** аналогично предыдущему ответу. Проверочное письмо – не спам!
### Реализация на языке программирования R
Комментировал почти каждое свое действие, ибо знаю, насколько порой не хочется разбираться в чужом коде, поэтому надеюсь, чтение моего не вызовет у вас трудностей. (ой как надеюсь)
**А тут, собственно, и сам код**
```
library("tm") #Библиотека для stopwords
library("stringr") #Библиотека для работы со строками
#Обучаюшая выборка со спам письмами:
spam <- c(
'Путевки по низкой цене',
'Акция! Купи шоколадку и получи телефон в подарок'
)
#Обучающая выборка с не спам письмами:
not_spam <- c(
'Завтра состоится собрание',
'Купи килограмм яблок и шоколадку'
)
#Письмо требующее проверки
test_letter <- "В магазине гора яблок. Купи семь килограмм и шоколадку"
#----------------Для спама--------------------
#Убираем все знаки препинания
spam <- str_replace_all(spam, "[[:punct:]]", "")
#Делаем все маленьким регистром
spam <- tolower(spam)
#Разбиваем слова по пробелу
spam_words <- unlist(strsplit(spam, " "))
#Убираем слова, которые совпадают со словами из stopwords
spam_words <- spam_words[! spam_words %in% stopwords("ru")]
#Создаем таблицу с уникальными словами и их количеством
unique_words <- table(spam_words)
#Создаем data frame
main_table <- data.frame(u_words=unique_words)
#Переименовываем столбцы
names(main_table) <- c("Слова","Спам")
#---------------Для не спама------------------
not_spam <- str_replace_all(not_spam, "[[:punct:]]", "")
not_spam <- tolower(not_spam)
not_spam_words <- unlist(strsplit(not_spam, " "))
not_spam_words <- not_spam_words[! not_spam_words %in% stopwords("ru")]
#---------------Для проверки------------------
test_letter <- str_replace_all(test_letter, "[[:punct:]]", "")
test_letter <- tolower(test_letter)
test_letter <- unlist(strsplit(test_letter, " "))
test_letter <- test_letter[! test_letter %in% stopwords("ru")]
#---------------------------------------------
#Создаем новый столбик для подсчета не спам писем
main_table$Не_спам <- 0
for(i in 1:length(not_spam_words)){
#Создаем логическую переменную
need_word <- TRUE
for(j in 1:(nrow(main_table))){
#Если "не спам" слово существует, то к счетчику уникальных слов +1
if(not_spam_words[i]==main_table[j,1])
{
main_table$Не_спам[j] <- main_table$Не_спам[j]+1
need_word <- FALSE
}
}
#Если слово не встречалось еще, то добавляем его в конец data frame и создаем счетчики
if(need_word==TRUE)
{
main_table <- rbind(main_table,data.frame(Слова=not_spam_words[i],Спам=0,Не_спам=1))
}
}
#-------------
#Создаем столбик содержащий вероятности того, что выбранное слово - спам
main_table$Вероятность_спам <- NA
#Создаем столбик содержащий вероятности того, что выбранное слово - не спам
main_table$Вероятность_не_спам <- NA
#-------------
#Создаем функцию подсчета вероятности вхождения слова Xi в документ класса Qk
formula_1 <- function(N_ik,M,N_k)
{
(1+N_ik)/(M+N_k)
}
#-------------
#Считаем количество слов из обучающей выборки
quantity <- nrow(main_table)
for(i in 1:length(test_letter))
{
#Используем ту же логическую переменную, чтобы не создавать новую
need_word <- TRUE
for(j in 1:nrow(main_table))
{
#Если слово из проверочного письма уже существует в нашей выборке то считаем вероятность каждой категории
if(test_letter[i]==main_table$Слова[j])
{
main_table$Вероятность_спам[j] <- formula_1(main_table$Спам[j],quantity,sum(main_table$Спам))
main_table$Вероятность_не_спам[j] <- formula_1(main_table$Не_спам[j],quantity,sum(main_table$Не_спам))
need_word <- FALSE
}
}
#Если слова нет, то добавляем его в конец data frame, и считаем вероятность спама/не спама
if(need_word==TRUE)
{
main_table <- rbind(main_table,data.frame(Слова=test_letter[i],Спам=0,Не_спам=0,Вероятность_спам=NA,Вероятность_не_спам=NA))
main_table$Вероятность_спам[nrow(main_table)] <- formula_1(main_table$Спам[nrow(main_table)],quantity,sum(main_table$Спам))
main_table$Вероятность_не_спам[nrow(main_table)] <- formula_1(main_table$Не_спам[nrow(main_table)],quantity,sum(main_table$Не_спам))
}
}
#Переменная для подсчета оценки класса "Спам"
probability_spam <- 1
#Переменная для подсчета оценки класса "Не спам"
probability_not_spam <- 1
for(i in 1:nrow(main_table))
{
if(!is.na(main_table$Вероятность_спам[i]))
{
#Шаг 1.1 Определяем оценку того, что письмо - спам
probability_spam <- probability_spam * main_table$Вероятность_спам[i]
}
if(!is.na(main_table$Вероятность_не_спам[i]))
{
#Шаг 1.2 Определяем оценку того, что письмо - не спам
probability_not_spam <- probability_not_spam * main_table$Вероятность_не_спам[i]
}
}
#Шаг 2.1 Определяем оценку того, что письмо - спам
probability_spam <- (length(spam)/(length(spam)+length(not_spam)))*probability_spam
#Шаг 2.2 Определяем оценку того, что письмо - не спам
probability_not_spam <- (length(not_spam)/(length(spam)+length(not_spam)))*probability_not_spam
#Чья оценка больше - тот и победил
ifelse(probability_spam>probability_not_spam,"Это сообщение - спам!","Это сообщение - не спам!")
```
Спасибо большое за потраченное время на чтение моей статьи. Надеюсь, Вы узнали для себя что-то новое, или просто пролили свет на непонятные для Вас моменты. Удачи!
**Источники:**
1. [Очень хорошая статья о наивном бейесовском классификаторе](http://bazhenov.me/blog/2012/06/11/naive-bayes.html)
2. Черпал знания из Wiki: [тут](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B1%D0%B0%D0%B9%D0%B5%D1%81%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80), [тут](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D0%B9%D0%B5%D1%81%D0%BE%D0%B2%D1%81%D0%BA%D0%B0%D1%8F_%D1%84%D0%B8%D0%BB%D1%8C%D1%82%D1%80%D0%B0%D1%86%D0%B8%D1%8F_%D1%81%D0%BF%D0%B0%D0%BC%D0%B0), и [тут](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D0%BF%D1%80%D0%B0%D0%B2%D0%B4%D0%BE%D0%BF%D0%BE%D0%B4%D0%BE%D0%B1%D0%B8%D1%8F)
3. Лекции по Data Mining Чубуковой И.А. | https://habr.com/ru/post/415963/ | null | ru | null |
# Ускоряем передачу данных в localhost
[](https://habrahabr.ru/post/320508)
Один из самых быстрых способ межпроцессного взаимодействия реализуется при помощи разделяемой памяти (Shared Memory). Но мне казалось не логичным, что в найденных мною алгоритмах, память всё равно нужно копировать, а после перезапуска клиента (причём он допускался только один) нужно перезапускать и сервер. Взяв волю в кулак, я решил разработать полноценный клиент-сервер с использованием разделимой памяти.
И так, вначале нужно определить функциональные требования к разрабатываемому клиент-серверу. Первое и основное требование: данные не должны копироваться. Во вторых, «мультиклиентность» — к серверу могут подключаться несколько клиентов. В третьих, клиенты могут переподключаться. И в четвёртых, по возможности ПО должно быть кроссплатформенно. Из налагаемых требований, можно выделить составные части архитектуры:
* компонент, инкапсулирующий работу с разделяемой памятью;
* менеджер памяти (allocator);
* компонент, инкапсулирующий работу с пересылаемым буфером данных и
реализующий идеологии «copy on write»(далее CBuffer);
* межпроцессный мютекс;
* межпроцессная условная переменная или её аналог;
* и непосредственно клиент и сервер.
Проблем работы с разделяемой памятью [достаточно много](http://www.boost.org/doc/libs/1_60_0/doc/html/interprocess/sharedmemorybetweenprocesses.html). Поэтому не будем изобретать велосипед и возьмём от boost.interprocess по максимуму. Во-первых, возьмём классы shared\_memory\_object, mapped\_region, которые облегчат нам работы с разделяемой памятью в linux и windows. От туда можно взять и реализацию IPC семафора – который будет выполнять функции как мютекса так и условной переменной. Также возьмём в качестве образца для CBuffer, boost реализацию std::vector (При работе с разделяемой памятью оперировать указателями нельзя, только смещениями. Поэтому std::vector + allocator нам не подойдёт). Ещё в boost можно найти реализацию межпроцессного deque, но как это использовать при разработке клиент-сервера я не нашёл. И остался только вопрос с менеджером памяти(allocator) для разделяемой памяти. Естественно, и он есть в boost, но он ориентирован на решение других задач. Таким образом, от boost будут взяты не требующие компилирования библиотеки (header only). Хотя boost под MSVC может с этой точкой зрения не согласиться, поэтому не забываем про дубину – препроцессор BOOST\_ALL\_NO\_LIB запрещающий использовать «pragma comment».(Воспоминания из ночного монолога: «Какого чёрта линкуются библиотеки boost!»)
Реализация клиента и сервера
----------------------------
Реализация передачи данных между клиентами и серверов достаточно тривиальна. Она похоже на реализацию модели поставщик-потребитель (producer-customer) с использованием семафоров, где в качестве «передаваемого» сообщения используется смещение (адрес) передаваемого буфера, а объекты синхронизации заменены на их межпроцессные аналоги. Каждому клиента и серверу соответствует своя очередь смещений, которая играет роль приёмного буфера и семафор, который отвечает за уведомление об изменении очереди. Соответственно, когда буфер отправляется другому процессу, то смещение буфера кладётся в очередь, а семафор освобождается(post). Далее другой процесс считывает данные и захватывает семафор (wait). По умолчанию процесс не ждёт получения данных другим процессом(nonblock). Пример реализации можно взять [отсюда](https://docs.oracle.com/cd/E19455-01/806-5257/sync-15907/index.html). На практике, помимо передачи самого буфера зачастую необходимо еще передать идентифицирующую информацию. Обычно это целочисленное число. Поэтому в метод Send добавлена возможность передачи числа.
#### Как клиенты подключаются к серверу?
Алгоритм достаточно прост, данные о сервере лежат строго по определённому смещению в разделяемой памяти. Когда клиент «открывает» разделяемую память он считывает структуру по заданному адресу, если её нет, то сервер отсутствует, если есть, то он выделяет память для структуры данных клиента, заполняет её и возбуждает событие на сервере с указанием смещения на структуру. Далее сервер добавляет нового клиента в связанный список клиентов и возбуждает в клиенте событие «подключён». Отключения осуществляется аналогичным образом.
#### Оценка состояния соединения
Проверка состояния соединения между клиентом и сервером построена аналогично TCP. С интервалом времени отправляется пакет жизни. Если он не доставлен – значит, клиент «рухнул». Также чтобы избежать возможных взаимных блокировок(dead lock) из-за «рухнувшего» клиента, который не освободил объект синхронизации, память для пакета жизни выделяется из собственного резерва сервера.
Реализация менеджера памяти
---------------------------
Как оказалась, самая сложная задача в реализации подобно IPC — это реализация менеджера памяти. Он ведь должен не просто реализовать методы malloc и free по одному из известных алгоритмов, но и не допустить утечки при «падении» клиента, предоставить возможность «резервировать» память, выделять блок памяти по конкретному смещению, не допускать фрагментирования, быть потокобезопасным, а в случаи отсутствия свободных блоков требуемого размера, ожидать его появления.
#### Базовый алгоритм
За основу реализации менеджера памяти был взят Free List алгоритм. Согласно этому алгоритму, все не выделенные блоки памяти объединяются в односторонний связанный список. Соответственно, при выделении блока памяти (malloc), ищется первый свободный блок, размер которого не меньше требуемого, и удаляется из связанного списка. Если размер запрашиваемого блока меньше чем размер свободного, то свободный блок разбивается на два, первый равен запрашиваемому размеру, а второй «лишнему». Первый блок – это выделенный блок памяти, а второй добавляется в список свободных блоков. При освобождении блока памяти(free), освобождаемый блок добавляется в список свободных. Далее соседние свободные блоки памяти объединяются в один. В сети есть множества реализация менеджера памяти с алгоритмом Free List. Я использовал алгоритм [heap\_5](http://www.freertos.org/a00111.html) из FreeRTOS.
#### Алгоритмические особенности
С точки зрения разработки менеджера памяти, отличительной особенностью работы с разделяемой памятью является отсутствие «помощи» со стороны ОС. Поэтому помимо списка свободных блоков памяти, менеджер также обязан сохранять информацию о владельце блока памяти. Сделать это можно несколькими способами: хранить в каждом выделенном блоке памяти PID процесса, создать таблицу «смещение выделенного блока памяти – PID», создать массив выделенных блоков памяти для каждого PID отдельно. Поскольку количество процессов обычно мало (не больше 10), то было принято гибридное решение, в каждом выделенном блоке памяти храниться индекс (2 байта) массива смещений выделенных блоков памяти, каждому PID соответствует свой массив, который расположен в конце «блока процесса» (в этом блоке храниться информация о процессе) и является динамическим.
Массив организован хитро, если блок памяти выделен процессом, то в ячейке храниться смещение выделенного блока памяти, если блок памяти не выделен, то в ячейке содержится индекс следующей «не выделенной» ячейки (фактически организован односвязный список «свободных» ячеек массива, как в алгоритме Free List). Такой алгоритм работы массива, позволяет производить удаление и добавление адреса за константное время. Причём при выделение нового блока искать таблицу соответствующую текущему PID необязательно, её смещение всегда известно заранее. А если сохранять смещение «блока процесса» в выделенном блоке памяти, то при освобождении блока искать таблицу также не надо. Из-за принятого допущения о малости количества процессов, «блоки процессов» объединены в односторонний связанный список. Таким образом, при выделении нового блока памяти (malloc) сложность добавление информации о владельце равна О(1), а при освобождении(free) блока памяти О(n), где n – количество процессов использующих разделяемую память. Почему нельзя использовать дерево или хэш-таблицы для быстрого поиска смещения «блока процесса»? Массив выделенных блоков является динамическим, следовательно, смещение у «блока процессов» может измениться.
Как писалось выше, для работы «клиент-сервера» необходимо добавить возможность «резервирования» блоков памяти. Это реализуется достаточно просто, резервный блок памяти «выделяется»для процесса. Соответственно, когда необходимо выделить блок памяти из резерва, то резервный блок процесса освобождается, и далее операции аналогичны обычному выделению. Далее, выделения блока памяти по заданному адресу реализуется тоже просто, т.к. информация о выделанных блоках храниться в «блоке процесса».
При таком большом количестве постоянно хранящейся служебной информации может возникнуть фрагментация памяти из-за разной времени «жизни» блоков, поэтому в менеджере памяти вся служебная информация(большое время жизни) выделяется с конца области, а выделение «пользовательских» блоков(малое время жизни) сначала. Таким образов, служебная информация будет фрагментировать память только при отсутствии свободных блоков.
Структура памяти представлена на рисунке ниже.
**Структура памяти**
#### А что произойдет, если один из процессов использующих разделяемую память рухнет?
К сожалению, я не нашёл способа получить событие от ОС «процесс завершился». Но есть возможность проверить существует процесс или нет. Соответственно, когда в менеджере памяти возникает ошибка, например, закончилась память, то менеджер памяти проверяет состояние процессов. Если процесса не существует, то на основании данных хранящихся в «блоке процесса» утекшая память возвращается в оборот. К сожалению, из-за отсутствия события «процесс завершился», может возникнуть ситуация когда процесс рухнул в момент владения межпроцессным мъютексом, что естественно приведёт к блокировке менеджера памяти и невозможности запуска «очистки». Чтобы этого избежать, в заголовок добавлена информация о PID владельца мъютекса. Поэтому, при необходимости, пользователь можно вызывать проверку принудительно, скажем каждых 2 секунды. (метод watch dog)
Из-за использования «copy-on-write», может произойти ситуация, когда буфером владеют одновременно несколько процессов, причём по закону подлости, один из них рухнул. В этом случае могут возникнуть две проблемы. Первая, если рухнувший процесс являлся владельцем буфера, то он будет удалён, что приведёт к SIGNSEV у других процессов. Вторая, из-за того что рухнувший процесс не уменьшил счётчик в буфере, то он никогда не будет удалён, т.е. возникнет утечка. Простого и производительного решения этой проблемы я не нашёл, но, к счастью, такая ситуация редкость, поэтому я принял волевое решение, если кроме упавшего процесса есть ещё один владелец, то чёрт с ним, пусть память утекает, буфер перемещается к процессу запустившему очистку.
Обычно менеджер памяти в случае отсутствия свободного блока памяти возвращает NULL или выбрасывает исключение. Но нас ведь «интересует» не выделения блока памяти, а его передача, т.е. отсутствие свободного блока, говорит не об ошибке, а о необходимости подождать пока другой процесс освободит блок. Ожидание в цикле, обычно дурно пахнет. Поэтому менеджер имеет два режима выделения: классический, если нет свободного блока, возвращает NULL и ожидающий, если нет свободного блока, то процесс блокируется.
Реализация оставшихся компонентов
---------------------------------
Основу реализации оставшихся компонентов составляет boost, поэтому далее я остановлюсь только на их особенностях. Особенностью компонента, инкапсулирующего работу с разделяемой памятью (далее CSharedMemory) наличие заголовка с межпроцессным мютексом для синхронизации методов работы с разделяемой памятью. Как показала практика, без него не обойтись. Поскольку обычно размер буфера данных не изменяется или изменяется только с начала (например, вставка заголовка в буфера данных для передачи по сети.) алгоритм резервирование памяти в CBuffer отличен от коэффициентного алгоритма резервирования памяти в std::vector. Во-первых, в реализации CBuffer добавлена возможность задавать резерв сначала, по умолчанию он равен 0. Во-вторых, алгоритм резервирования памяти следующий: если размер выделяемого блока меньше 128 байт, то резервируется 256 байт, если размер буфера данных меньше 65536, то резервируется размер буфера плюс 256 байт, в противном случае резервируется размер буфера плюс 512 байт.
#### Несколько слов по поводу использования sem\_init в Linux
Основные источники дают не совсем корректную версию программного кода использования sem\_init между процессами. В Linux необходимо выравнивать память для структуры sem\_t, например вот так:
```
(_sem_t*)(((uintptr_t)mem+__alignof(sem_t))&~(__alignof(sem_t)-1)
```
Поэтому, если у вас sem\_post(sem\_wait) возвращает EINVAL, попробуйте выровнять память для структуры sem\_t. [Пример работы с sem\_init](https://github.com/kraj/glibc/blob/master/tst-sem3.c).
Итого
-----
В результате получился клиент-сервер, скорость передачи которого не зависит от объёма данных, она зависит только от размера передаваемого буфера. Цена этому – некоторые ограничения. В Linux наиболее существенное из них — это «утечка» памяти после «завершения» процесса. Её можно удалить вручную или перезапустить ОС. При использовании в windows проблема иная, там «утекает» разделяемая память на жёстком диске, если она не была удалена вызовом метода класса сервера. Эта проблема не устраняется перезапуском ОС, только ручным удалением файлов в папке boost\_interprocess. Поскольку мне иногда приходиться работать со старыми компиляторами, в репозитории лежит boost версии 1.47, хотя с последними версиями, библиотека работает шустрее.
Результаты тестирования представлены на графике ниже (Linux и QNX тестировались в виртуальной машиной VMBox)
Где взять исходники?
--------------------
Исходный код стабильной версии лежит [здесь](https://github.com/CrazyLauren/sm_lib). Там же есть и [бинарники](https://github.com/CrazyLauren/sm_lib/releases) (+ VC redistributable) для быстрого запуска теста. Для любителей QNX в исходниках есть toolchain для CMake. Напоминаю, если CMake не собирает исходники, почистите переменные окружения, оставляя только каталоги целевого компилятора.
И напоследок [ссылка](http://yurovsky.github.io/2015/06/04/lockfree-ipc) на реализацию LookFree IPC с использованием разделяемой памяти. | https://habr.com/ru/post/320508/ | null | ru | null |
# Заменяем бут-анимацию Android устройства на мелькающие логи Linux ядра
После разработки кастомного загрузчика для своего телефона мне захотелось реализовать вывод ядерных логов на дисплей, как это умеют делать десктопные дистрибутивы Linux. А всё потому, что лично мне при загрузке телефона намного интереснее наблюдать мелькающие kmsg логи, нежели наблюдать сначала логотип загрузчика, а затем ещё и бут-анимацию Android системы. За два года «скучные обоины» уже приелись.
Сейчас попытаюсь вкратце рассказать о модуле LLCON для Android ядра, который реализует низкоуровневый вывод kmsg логов на дисплей.
Сразу упомяну о том, что в любом Linux ядре есть модуль, который занимается выводом ядерных логов на экран. Данный механизм ядра включается при помощи указания опции FRAMEBUFFER\_CONSOLE. Но данный механизм работает только через драйвер дисплея, который обычно инициализируется в самую последнюю очередь (этап late\_init). Из-за этой особенности первичный логотип загрузчика будет отображаться довольно значительное время.
Слова «низкоуровневый вывод» я употребляю не спроста, т.к. модуль LLCON напрямую работает с видео-памятью (сразу вспоминаются юные поделки для MS-DOS) и при этом начинает свою работу перед инициализацией внутренних драйверов Linux ядра (early\_init). Именно данные особенности и позволяют LLCON начать вывод логов ядра на экран как можно быстрее.
После добавления LLCON модуля следует в конфиг ядра добавить следующие опции:
```
CONFIG_VT=y
CONFIG_LLCON=y
CONFIG_FONTS=y
CONFIG_FONT_6x11=y
CONFIG_FONT_8x16=y
CONFIG_FONT_SUN12x22=y
```
В данном случае я указал 3 разных шрифта, т.к. в используемом мною загрузчике можно выбирать любой шрифт. Но если нужно соблюдать минимальный размер образа ядра, то следует указать только один шрифт.
Перед стартом сборки доработанного ядра не стоит забыть предварительно добавить в BoardConfig новую опцию ядра:
```
androidboot.llcon=,,,,,,,,,
```
**Расшифровка параметров**
* mode:
0 = LLCON отключён
1 = синхронный вывод логов (постраничный скроллинг)
2 = асинхронный вывод логов (построчный скроллинг)
* delay:
задержка в миллисекундах (используется в потоке, выводящем графику на экран; рекомендуемое значение 100)
* textwrap:
0 = перенос текста на новые строки запрещён
1 = перенос текста на новые строки разрешён
* fb\_addr:
физический адрес FrameBuffer
* fb\_bpp:
формат пикселей дисплея (сейчас игнорируется)
* fb\_height:
высота дисплея в пикселях
* fb\_width:
ширина дисплея в пикселях
* fb\_stride:
размер одной строки в пикселях или в байтах
* font\_size:
размер шрифта (поддерживаемые значения: 6, 8, 10, 12)
* font\_color:
цвет символов в HEX формате
Пример:
```
androidboot.llcon=2,100,0,0x03200000,24,1280,720,720,8,0xFFFFFF
```
**Как узнать значение параметра fb\_addr**
Физический адрес FrameBuffer'а можно подсмотреть в DeviceTree собираемого ядра. Для этого ищите параметр «qcom,memblock-reserve» в ветке «qcom,mdss\_fb\_primary». Так же очень часто адрес FrameBuffer'а фигурирует в kmsg логах ядра.
Целиком копировать сюда исходники модуля LLCON я не стану, а только укажу ссылки на соответствующие патчи:
* для ядер версии 3.4: [github.com/jsr-d10/android\_kernel\_jsr\_msm8226/commits/mm-llcon5](https://github.com/jsr-d10/android_kernel_jsr_msm8226/commits/mm-llcon5)
* для ядер версии 3.10: [github.com/jsr-d10/android\_kernel\_jsr\_msm8228\_1.3.3/commits/d10-llcon5](https://github.com/jsr-d10/android_kernel_jsr_msm8228_1.3.3/commits/d10-llcon5)
Также стоит отметить, что без доработки init-модуля (который находится в ramdisk'е) при инициализации подсистем андройда начнётся воспроизводиться бут-анимация. Поэтому при использовании LLCON следует автоматизировать отключение бут-анимации, что выполняет вот этот [патч](https://github.com/jsr-d10/android_device_jsr_d10f/commit/bb7caef).
Демонстрация работы модуля LLCON:
* LLCON 1 — постраничный режим, шрифт 6x11
* LLCON 2 — построчный режим, шрифт 8x16
Модуль LLCON так же имеет дополнительный функционал, который полезен для:
* получения kmsg логов в случае экстренной перезагрузки SoC (когда даже last\_kmsg бесполезен);
* отладки ядра на самых ранних этапах инициализации (когда недоступны JTAG и UART).
Но об этих возможностях LLCON я постараюсь рассказать в следующий раз. | https://habr.com/ru/post/310886/ | null | ru | null |
# Тестирование «РУСТЭК-платформа»
*В связи с уходом некоторых вендоров из России мы решили потестировать отечественные системы виртуализации. Одним из главных критериев для нас как облачного провайдера было наличие мультитенантности. Именно по этой причине среди прочих взяли на тестирование отечественную систему виртуализации «РУСТЭК – платформа» и программный комплекс управления и оркестрации платформ виртуализации «РУСТЭК–ЕСУ». В этой статье расскажем именно про «РУСТЭК – платформа».*
Что такое «РУСТЭК-платформа»
----------------------------
Платформа РУСТЭК – это российская сервисная платформа виртуализации для создания и управления ИТ-инфраструктурой. Продукт создан российской компанией ООО "РУСТЭК", входит в единый реестр отечественного ПО (№ 981) и соответствует требованиям к импортозамещению. Ближайший зарубежный аналог – продукт VMware vCenter. Функционал платформы РУСТЭК включает в себя:
* Система управления — собственная разработка на базе OpenStack;
* Гипервизор — KVM;
* Специализированная ОС, оптимизированная под задачи платформы;
* Единый интерфейс для установки, обновления и масштабирования (конфигуратор);
* API для интеграции с другими системами;
* Развитая ролевая модель для обеспечения разделения прав при работе с платформой;
* Учёт текущей загрузки платформы;
* Автоматический перезапуск виртуальных машин (ВМ) на других физических серверах (высокая доступность);
* Горячая миграция ВМ на другие физические серверы;
* Автоматическая балансировка нагрузки между узлами кластера;
* Поддержка наиболее популярных российских и зарубежных ОС;
* Веб-портал для администраторов и пользователей.
\* (из документации РУСТЭК)
Тестовый стенд
--------------
Для тестирования построили вот такой стенд:
Платформу решили установить на 3 сервера. В качестве хранилища использовали кластер из двух Starwind серверов подключённых по ISCSI. Для работы High Availability необходим доступ до IPMI серверов (VLAN 887) из сети управления кластером (VLAN 886).
Теперь переходим непосредственно к установке РУСТЭК-платформы версии 2021.2.3
Загружаемся с образа и входим с учётными данными **root/rustack**, удаляем разделы с дисков командой wipefs и приступаем к установке ОС «РУСТЭК платформа» на сервер, выполнив команду
**rustack-os-install**
Откроется конфигуратор из 5 пунктов:
Здесь необходимо указать настройки сетевого интерфейса сети управления, выбрать диск на который будет производиться установка и пароль для сервера. После того как настройки указаны, нажимаем «Применить конфигурацию сервера» и РУСТЭК-платформа установится на сервер. Проделываем операцию на всех трёх серверах.
По умолчанию РУСТЭК ориентирован на блочное хранилище NFS, и по информации из документации, все можно настроить из конфигуратора кластера. Но у нас-то хранилище подключается по ISCSI.
Для доступа к хранилищу мы выделили по 2 отдельных сетевых интерфейса на каждом сервере. Сначала редактируем файл настроек сети и создаём отдельный bond для ISCSI. Добавляем в /etc/conf.d/net
```
slaves_bond1="eno51 eno52"
mode_bond1="active-backup"
miimon_bond1="100"
config_bond1="172.16.50.111/24"
mtu_bond1="9000"
```
И активируем его:
`ln -s /etc/init.d/net.lo /etc/init.d/net.bond1 && rc-update add net.bond1 && /etc/init.d/net.bond1 start`
Теперь необходимо подключить хранилище ISCSI:
* Генерируем имя инициатора ISCSI
`echo "InitiatorName=$(iscsi-iname)" > /etc/iscsi/initiatorname.iscsi`
* Включаем автозагрузку сервиса iscsid
`rc-update add iscsid && /etc/init.d/iscsid start`
* Добавляем интерфейс ISCSI
`iscsiadm -m iface -I iface0 -o new && iscsiadm -m iface -I iface0 --op=update -n iface.net_ifacename -v bond1`
* Получаем список доступных Target-ов на хранилищах
`iscsiadm --mode discoverydb --type sendtargets --interface=iface0 --portal 172.16.50.10 --discover && iscsiadm --mode discoverydb --type sendtargets --interface=iface0 --portal 172.16.50.20 –discover`
* Подключаем необходимые таргеты на хранилищах (для теста можно и без аутентификации)
`iscsiadm --mode node --targetname iqn.2008-08.com.starwindsoftware:10.0.110.110-rustack --interface=iface0 --portal 172.16.50.10:3260 --login && iscsiadm --mode node --targetname iqn.2008-08.com.starwindsoftware:10.0.110.120-rustack --interface=iface0 --portal 172.16.50.20:3260 –login`
* И конфигурируем их для автоматического подключения
`iscsiadm --mode node --targetname iqn.2008-08.com.starwindsoftware:10.0.110.110-rustack --interface=iface0 --portal 172.16.50.10:3260 -o update -n node.startup -v automatic && iscsiadm --mode node --targetname iqn.2008-08.com.starwindsoftware:10.0.110.120-rustack --interface=iface0 --portal 172.16.50.20:3260 -o update -n node.startup -v automatic`
Дальше необходимо включить multipath, для чего отредактируем конфигурационный файл:
```
defaults {
user_friendly_names no
find_multipaths yes
}
blacklist_exceptions {
## property (ID_WWN|SCSI_IDENT_.*)
property (ID_WWN|SCSI_IDENT_.*|ID_SERIAL)
}
```
Перезапускаем multipathd
`/etc/init.d/multipathd restart`
Узнаём и записываем WWID подключённого таргета (в дальнейшем он нам пригодится при установке кластера).
```
rustack-01 ~ # multipath -ll
2917b2a1fe2703a28 dm-1 STARWIND,STARWIND
size=900G features='0' hwhandler='1 alua' wp=rw
|-+- policy='service-time 0' prio=50 status=active
| `- 2:0:0:0 sdc 8:32 active ready running
`-+- policy='service-time 0' prio=50 status=enabled
`- 4:0:0:0 sde 8:64 active ready running
```
Ну а теперь печальная печаль – все эти действия необходимо повторить на всех серверах, которые будут входить в кластер (и если добавлять дополнительный сервер в кластер — тоже).
После того, как подключили хранилище ко всем нодам, можно настроить кластер. Выполнять установку кластера лучше из консоли сервера или посредством ssh c использованием менеджера терминалов tmux. При попытке развернуть кластер просто по ssh (без tmux) скрипт развёртывания кластера завис на одной из операций (с чем это связано — не могу сказать, но после запуска развёртывания кластера в консоли всё отработало штатно). Для запуска развёртывания кластера выполняем команду rustackctl на одном из серверов, и видим знакомое окно конфигуратора, но с другими пунктами меню.
Если кратко, то для развёртывания кластера, нам необходимо указать общие настройки, добавить хосты на которых будем разворачивать кластер и после этого применить созданную конфигурацию ко всем хостам.
А теперь поподробней. Заходим в общие настройки
* **Указываем виртуальный IP** — свободный IP-адрес в сети управления. после развёртывания кластера на этом IP будет висеть web-консоль управления платформой;
* **MTU физических интерфейсов** – указываем побольше (хранилка же по ISCSI подключена);
* **Диапазон VLAN** – задание не менее двух VLAN виртуальных сетей пользователей. Один из диапазонов VLAN используется для внутренних нужд платформы РУСТЭК;
* **Внешний VLAN** – задание диапазона VLAN. Если не предполагается доступ к ВМ из интернета – любое (не пересекающееся с диапазоном из предыдущего пункта) значение из диапазона от 2 до 4094. Допускается оставить значение по умолчанию;
* **CIDR внешней сети** – задание сети для внешних адресов ВМ. Если не предполагается доступ к ВМ из интернета, оставить значение по умолчанию;
* **Начало диапазона внешних IP** – задание первого адреса из пула внешних адресов ВМ. Если не предполагается доступ ВМ к интернету, оставить значение по умолчанию;
* **Конец диапазона внешних IP** – задание последнего адреса из пула внешних адресов ВМ;
* **Шлюз внешней сети** – задание шлюза для сети внешних адресов ВМ. Если не предполагается доступ ВМ к интернету, оставить значение по умолчанию.
Так как у нас хранилка подключена по ISCSI, то «тип дискового хранилища» «тип дискового хранилища для образов» выбираем OCFS2, и заполняем «Список WWID для OCFS2» значениями, которые получили, пока настраивали ISCSI. Можно указать несколько WWID, но после применения конфигурации примонтируется только одно хранилище. Второе придётся прописать в конфигах ручками (вендор обещал исправить такое поведение в ближайшем релизе).
Так, задали по минимуму настройки для кластера. Теперь будем добавлять хосты.
В Конфигураторе предусмотрено 5 шаблонов хостов (на самом деле 4). Отличаются они набором запускаемых служб.
* **Manual** – руками выбираем, какие службы будут запущены на хосте;
* **All-in-one** – все запускаем на одном хосте, HA – нет (это не наш вариант);
* **Primary** – набор служб для первичного контроллера;
* **Secondary** – набор служб для вторичного контроллера;
* **Compute** – набор служб для вычислительного узла.
Если режим высокой доступности (HA) не нужен, а хостов больше одного – то можно на один хост настроить роль «All-in-one», а на остальные хосты – «Compute».
В документации от новой версии появились замечательные таблички, в которых указано, какие службы и на каких хостах должны работать. Здесь приведу такую табличку для нашего мини-кластера высокой доступности:
Кстати, по умолчанию в шаблоне «Primary» служба «Вычислительный узел» отключена. Включаем её, ибо нечего благородным ядрам зазря простаивать.
Добавляем наши хосты в кластер. Включаем службы на хостах, как указано в таблице. Возвращаемся в главное меню Конфигуратора и нажимаем кнопку «Применить конфигурацию РУСТЭК» и «Откиньтесь на спинку кресла и отдохните…». А в этот время ansible создаст кластерное хранилище настроек и настроит все необходимые службы на хостах. После того, как Ansible скажет нам, что он справился и всё хорошо (если нехорошо, то смотрим /var/log/rustack-ansible.log), выходим из конфигуратора.
Наступает следующий эпизод квеста «найди пароль от панели управления». На самом деле тут всё просто. Выполняем волшебную команду:
`python3 -c "import yaml;print({k:v for k,v in dict(yaml.safe_load(open('/etc/openstack/clouds.yml'))['clouds']['rustack' ]['auth']).items() if k in ('username','password')})"`
и получаем наши логин и пароль от панели управления:
`{'username': 'admin', 'password': 'fk985KXh'}`
Кстати, судя по документации, к новой версии пароль получить стало проще:
`cat /var/lib/rustack-ansible/creds/keystone/admin_pass`
Когда все квесты пройдены, можно зайти в панель управления платформой и начать создавать свою виртуальную инфраструктуру.
Ошибка второго дня использования
--------------------------------
На следующий день после развёртывания платформы, при попытке войти в панель управления я лицезрел вот такое сообщение:
Погадав на кофейной гуще и перезапустив Redis, смог войти в панель управления. Но где-то в глубине души поселилась тревога, что где-то что-то не так. И действительно, спустя какое-то время я снова получил ту же ошибку и не смог попасть в панель управления. Пришлось подключать тяжелую артиллерию и смотреть логи, а логов генерится очень много. Среди кучи строк внимание заслужила одна:
`«Nov 23 09:33:24 rustack-01 pgbouncer[5307]: accept() failed: Too many open files»`
Отправил запрос вендору, и начал параллельно гуглить, что это за ошибка и как её победить? Но вендор оказался быстрей:
> “В данном случае мы уперлись в выделенные лимиты, для pgbouncer - `/etc/security/limits.d/11-postgres.conf`
>
> Чтобы проверить наверняка, можно выполнить следующие команды
> `psql -U postgres -p 6432 -h pgbouncer -c "show lists;"`
> нас интересует значение used\_clients, скорее всего, оно было под потолок
>
> далее выполним
> `psql -U postgres -p 6432 -h pgbouncer -c "show pools;"`
> нас интересуют основные потребители коннектов, их мы и будем фиксить.”
>
>
Дело в том, что по умолчанию для большинства служб openstack по дефолту создаются воркеры по числу ядер, например для nova-conductor
| | |
| --- | --- |
| workers = None | (Integer) Number of workers for OpenStack Conductor service. The default will be the number of CPUs available. |
Соответственно, если у вас CPU(s) — 64, получаем 64 воркера, каждый из которых создаёт нагрузку для pgbouncer и забирает файловый дескриптор, вот мы и упираемся в выделенные лимиты.
Чтобы пофиксить эту проблему (после того, как мы определили основные службы openstack, что потребляют коннекты pgbouncer), требуется на контроллерах в конфигурационных файлах соответствующих служб выставить конкретные значения для соответствующих воркеров и перезапустить эти службы.
Например, nova.conf
```
[DEFAULT]
…
osapi_compute_workers = 16
metadata_workers = 16
…
[conductor]
workers = 16
…
```
Для тестовых стендов за глаза хватит 4/8, на проде можно выставить 16, для более точных настроек надо снимать статистику по нагрузке.
Оказалось, что тестовый стенд был слишком «жирным» для конфигурации по умолчанию. После изменения лимитов в конфигах и перезапуска служб всё штатно запустилось и работает по сей день.
Теперь кратко итоги по результатам установки
--------------------------------------------
Минусы:
* Ручное подключение ISCSI-хранилищ;
* Нельзя настроить отдельный сетевой интерфейс для ISCSI в конфигураторе;
* Некорректно монтируются ISCSI таргеты, если их больше одного;
* На определённой итерации кластер так и не развернулся (возможно, виноват сам, что запустил установку по ssh без tmux).
Плюсы:
* Поддержка вендора – просто огонь. Отвечают оперативно. В своём продукте ориентируются отлично. Если нужна помощь, подключаются в этот же или на следующий день;
* Документация. Она есть и она постоянно дорабатывается.
---
### Что ещё интересного есть в блоге Cloud4Y
→ [Информационная безопасность и глупость: необычные примеры](https://habr.com/ru/company/cloud4y/blog/696078/)
→ [NAS за шапку сухарей](https://habr.com/ru/company/cloud4y/blog/703540/)
→ [Как распечатать цветной механический телевизор на 3D-принтере](https://habr.com/ru/company/cloud4y/blog/668962/)
→ [Создание e-ink дисплея с прогнозом погоды](https://habr.com/ru/company/cloud4y/blog/699638/)
→ [Аналоговый компьютер Telefunken RA 770](https://habr.com/ru/company/cloud4y/blog/701274/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. А ещё напоминаем про второй сезон нашего сериала ITить-колотить. Его можно посмотреть на [YouTube](https://youtu.be/8arneYYzsJw)и [ВКонтакте](https://vk.com/video/playlist/-114833493_1). | https://habr.com/ru/post/709570/ | null | ru | null |
# Тонкости R. Как минута час экономит
Довольно часто enterprise задачи по обработке данных затрагивают данные, сопровождаемые временной меткой. В R такие метки, обычно хранятся как класс `POSIXct`. Выбор методов работы с таким типом данных по принципу аналогии может привести к большому разочарованию и убеждению о крайней медлительности R. Хотя если взглянуть на эту чуть более пристально, то оказывается, что дело не совсем в R, а в руках и голове.
Ниже затрону пару кейсов, которые встретились в этом месяце и возможные варианты их решения. В ходе решения появляются весьма интересные вопросы. Заодно упомяну инструменты, которые оказываются крайне полезными для решения подобных задачек. Практика показала, что об их существовании знают немногие.
Кейс №1. Обработка событийных данных ИТ системы
===============================================
С точки зрения бизнеса задача «как бы» тривиальная. Необходимо в доходчивом виде отобразить событийный поток распределенной системы за определённый временной промежуток. А потом обеспечить разнообразную критериальную «нарезку». В качестве источника данных выступают подсистемы логирования компонентов ИТ системы.
С позиции удобства восприятия для высокоуровневого обзора подобных данных оптимально подходит представление в виде «тепловой карты». Вот пример сгенерированного графика.
Изобретать велосипед смысла нет, был использован подход, описанный в статье [«Bob Rudis, Making Faceted Heatmaps with ggplot2»](https://rud.is/projects/facetedheatmaps.html). Собственно говоря, поскольку данные по своей сути идентичны и представляют собой временную метку с соответствующим набором метрик, далее я буду апеллировать к этой статье и публично опубликованным данным, дабы не раскрывать частную информацию.
Нюанс №1
--------
заключается в том, что источников поступления событий несколько и находятся они в разных часовых поясах. Время в исходных данных измеряется в UTC, а аналитику надо привязывать к рабочему циклу по времени локального часового пояса. Исходные данные выглядят следующим образом:
где `timestamp` — UTC время события в формате ISO8601 в текстовом виде, tz — маркер тайм-зоны в которой это событие произошло.
Нюанс №2
--------
заключается в том, что используемый в статье подход `dplyr::do()` является устаревшим с момента выхода пакета `purrr`. Комментарий автора: [dplyr::do() is now basically deprecated in favour of the purrr approach](https://twitter.com/hadleywickham/status/719542847045636096). А это значит, что код надо бы адаптировать под современный подход.
Сразу переходим к `purrr`, пропускаем подходы, связанные с циклами for и враппером `Vectorize`, как неэффективные. К сожалению, попытки применить «в лоб» векторизацию к `POSIXct` векторам значений с различным timezone невозможно. Ответ находится в результате пристального взгляда на вектор `POSIXct` значений функцией `dput`. Timezone является атрибутом вектора, но не отдельного элемента!
По этой причине применение функционального подхода `map` к `POSIXct` переменной методом поэлементной обработки дает удручающий результат: на выборке в 20 тыс записей время процессинга составляет почти 20 секунд. При этом используются свойства векторизации функции `ymd_hms()`, в противном случае результат был бы ещё хуже.
```
attacks_raw <- read_csv("./data/eventlog.csv", col_types="ccc", progress=interactive()) %>%
slice(1:20000)
attacks <- attacks_raw %>%
# mutate(rt=map(.$timestamp, ~ ymd_hms(.x, quiet=FALSE))) %>% # с этим подходом ~ в 8 раз медленнее
mutate(rt=ymd_hms(timestamp, quiet=FALSE)) %>%
mutate(hour=as.numeric(map2(.$rt, .$tz, ~ format(.x, "%H", tz=.y)))) %>%
mutate(wkday_text=map2(.$rt, .$tz, ~ weekdays(as.Date(.x, tz=.y)))) %>%
unnest(rt, hour, wkday_text)
```
Пытаемся выяснить причину такого поведения. Для этого воспользуемся инструментом профилирования кода. Заинтересованные могут в качестве старта посмотреть детали на сайте Profvis: [Profvis — Interactive Visualizations for Profiling R Code](https://rstudio.github.io/profvis/), а также ознакомиться с видео:
* [2016 Shiny Developer Conference Videos: Profiling and performance — Winston Chang](https://www.rstudio.com/resources/webinars/shiny-developer-conference/);
* [rconf2017: Understand Code Performance with the profiler – Winston Chang](https://www.rstudio.com/resources/videos/understand-code-performance-with-the-profiler/).
Результат профилирования выглядит следующим образом:
Видно, что основное время уходит на многократные преобразования `POSIXct`, `POSIXlt`. Этому есть определённые объяснения, с отдельными позициями можно ознакомиться здесь: [«Why are lubridate functions so slow when compared with as.POSIXct?»](http://stackoverflow.com/questions/10645815/why-are-lubridate-functions-so-slow-when-compared-with-as-posixct).
Но для нас основных выводов несколько:
1. максимально вытащить все штучные действия с датами за пределы функции;
2. использовать векторизацию для значений `POSIXct`, обладающих одинаковым tz (т.е. мы не будем вынуждены передавать time-zone как параметр);
3. использовать особенности пакета `lubridate`, когда при соблюдении определённых форматов текста конвертация `chr->POSIXct` осуществляется не базовыми функциями R, а многократно оптимизированными (см. пакет `fasttime`).
4. вместо `dplyr::do` используем `purrr::map2`.
Незначительно модифицировав код получаем ускорение почти **в 25 раз**. (при прогоне на большем массиве данных выигрыш получается почти **в 100 раз**).
Код выглядит следующим образом:
```
attacks_raw <- read_csv("./data/eventlog.csv", col_types="ccc", progress=interactive()) %>%
slice(1:20000)
parseDFDayParts <- function(df, tz) {
real_times <- ymd_hms(df$timestamp, tz=tz, quiet=TRUE)
tibble(wkday=weekdays(as.Date(real_times, tz=tz)),
hour=as.numeric(format(real_times, "%H", tz=tz)))
}
attacks <- attacks_raw %>%
group_by(tz) %>%
nest() %>%
mutate(res=map2(data, tz, parseDFDayParts)) %>%
unnest()
```
Одной из ключевых «фишек» является группировка по time-zone с последующей векторизацией обработки.
Кейс №2. Скользящее окно по временным данным
============================================
Бизнес-кейс также является тривиальным. Есть массив временных данных, характеризующих время отклика на действия пользователя.
Необходимо посчитать [APDEX индекс](http://www.apdex.org/) для оценки удовлетворённости пользователей работой приложения.
```
# Разбиваем, все выполненные операции на 3 категории:
# N – общее количество произведённых операций
# NS - количество итераций, которые выполнены за менее чем целевое время [0 – Т]
# NF – количество операция, которые выполнены за (Т – 4Т]
# (т.е от целевого времени до целевого времени умноженного на 4)
# Индекс APDEX = (NS + NF/2)/N.
```
В качестве стартовой точки используем ужасающие результаты подсчета метрики по скользящему окну средствами базового R. Для выборки в 2000 записей время расчёта составляет почти **2 минуты**!
```
apdexf <- function(respw, T_agreed = 1.2) {
which(0 < respw$response_time & respw$response_time < T_agreed)
apdex_N <- length(respw$response_time) #APDEX_total
apdex_NS <- length(which(respw$response_time < T_agreed)) # APDEX_satisfied
apdex_NF <- length(which(T_agreed < respw$response_time & respw$response_time < 4*T_agreed)) # APDEX_tolerated F=4T
apdex <- (apdex_NS + apdex_NF/2)/apdex_N
return(apdex)
}
dt = dminutes(15)
df.apdex = data.frame(timestamp=numeric(0), apdex=numeric(0))
for(t in seq(from = start_time, by = dt, length.out = floor(as.duration(end_time - start_time)/dt))){
respw <- subset(mydata, t <= timestamp & timestamp < t+dt)
df.apdex <- rbind(df.apdex, data.frame(timestamp = t, apdex = apdexf(respw)))
}
```
Пропускаем все промежуточные шаги, сразу отмечаем места для оптимизации.
1. Переход на функциональную обработку.
2. Вынос всех константных вычислений за пределы функции, вызываемой в цикле. В частности, статус `satisfied\tolerated\frustrated` является только функцией времени отклика, но не времени измерения или окна расчёта — на вынос.
3. Крайне важный момент — непродуктивное копирование объектов!!! Несмотря на то, что `data.frame` передается в функцию по ссылке, операции с `data.frame` внутри функции могут приводить к созданию дубликата объекта, а это есть значительные накладные расходы. Оптимизация операций с использованием особенностей методов `dplyr` позволяет минимизировать количество копирования данных внутри функции, что существенно увеличивает производительность. С особенности методов `dplyr`, а также средствами контроля объектов, в частности, функцией `dplyr::changes()` можно ознакомиться в статье [«Data frame performance»](https://cran.r-project.org/web/packages/dplyr/vignettes/data_frames.html). Ровно поэтому модель отдельных колонок со статусом времени отклика гораздо предпочтительнее одной колонки с типом статуса времени отклика.
4. Проводим расчёт диапазона временных окон один раз при старте вычислений с применением свойства векторизации. Расчет `POSIXct` + сдвижка по времени — весьма накладная процедура, чтобы выполнять её внутри цикла.
5. Используем оптимизированные функции `dplyr` с внешней параметризацией. Подобное ухищрение позволяет сократить затраты на вычисления и используемую память, но несколько усложняет синтаксис за счёт возврата от NSE [Non-Standard evaluation] к SE [Standard evaluation]. (`filter` --> `filter_`). В качестве вводной информации про SE\NSE можно ознакомиться здесь: [«Non-standard evaluation»](https://cran.r-project.org/web/packages/dplyr/vignettes/nse.html).
```
apdexf2 <- function(df, window_start, cur_time) {
t_df <- df %>%
filter_(lazyeval::interp(~ timestamp>var, var=as.name("window_start"))) %>%
filter_(lazyeval::interp(~ timestamp<=var, var=as.name("cur_time")))
# так быстрее на порядок, чем summarise
s <- sum(t_df$satisfied)
t <- sum(t_df$tolerated)
f <- sum(t_df$frustrated)
(s + t/2)/(s + t + f)
}
t_agreed <- 0.7
mydata %<>%
mutate(satisfied=if_else(t_resp <= t_agreed, 1, 0)) %>%
mutate(frustrated=if_else(t_resp > 4*t_agreed, 1, 0)) %>%
mutate(tolerated=1-satisfied-frustrated) %>%
mutate(window_start=timestamp-minutes(15))
time_df <- mydata %>%
select(window_start, timestamp)
mydata %<>%
select(timestamp, satisfied, tolerated, frustrated)
mydata$apdex <- map2(time_df$window_start, time_df$timestamp,
~ apdexf2(mydata, .x, .y)) %>%
unlist()
```
Проведя подобную оптимизацию получаем время обработки ~ 3.5 сек. Ускорение почти в **35 раз** и достигнуто оно просто незначительным переписыванием кода!
Но и это не предел. Приведённая реализация осуществляет расчёт скользящим окном для по каждой отдельной метрике. Измерения же могут приходить в произвольные моменты времени. Но на практике такая точность избыточна, вполне достаточно загрублять вычисление до 1-5 минут групповых интервалов. А это значит, что объем вычислений может уменьшиться ещё раз в 10, с пропорциональным сокращением времени вычисления.
В заключение хочу отметить, что существующий на настоящий момент набор пакетов и инструментов действительно позволяет писать на R компактно и быстро. В случае, когда и этого будет недостаточно, есть ещё резерв в виде `Rcpp` — написания отдельных функций на C++.
Предыдущий пост: [«R в enterprise задачах. Хитрости и трюки»](https://habrahabr.ru/post/322066/) | https://habr.com/ru/post/322890/ | null | ru | null |
# Реализация HTTP server push с помощью Server-Sent Events
На эту тему было уже много статей, но раскрыта далеко не вся правда. Для тех, кто пропустил — читайте [Создание приложений реального времени с помощью Server-Sent Events](http://habrahabr.ru/blogs/javascript/120429/) .
#### Как же работает Server-Sent-Events?
Простой пример:
`(new EventSource('/events')).addEventListener('message', function (e) {
document.getElementById('body').innerHTML += e.data + '
';
}, false);`
Браузер устанавливает http-соединение, и для каждого сообщения с сервера срабатывает событие, в обработчике которого мы можем получить текст сообщения. При этом вовсе не обязательно с серверной стороны разрывать соединение, как этого требует XMLHTTPRequest. Поэтому по **единожды** установленному соединению мы можем получать сообщения с сервера.
Еще одним плюсом Server-sent-events является то, что последняя спецификация теперь поддерживается браузерами Chrome, Opera 11+, заявлена поддержка в Firefox Aurora, а для браузеров IE8+, Firefox 3.5+ можно реализовать polyfill на javascript, для более старых браузеров полифил может использовать long-polling. Таким образом, EventSource лучше поддерживается, нежели WebSockets. (Нативную поддержку смотрим здесь — <http://caniuse.com/#search=eventsource>)
При этом для работы полифила с серверной стороны не требуется подключение каких-то библиотек, достаточно реализовать работу с Server-sent-events, как этого требует стандарт, а не писать код под каждый ajax-транспорт (как это сделано в socket.io, что сильно усложняет ее, больше транспортов — больше тонкостей)
И так, IE8 поддерживает **XDomainRequest**, который может работать по технологии server-push, т.е. мы можем также получать сообщения, не прерывая http-соединения.
К сожалению, XDomainRequest требует паддинг — **2 килобайта** в начале тела ответа, но это не проблема. Также, XDomainRequest не поддерживает установку заголовков запроса, поэтому *Last-Event-ID* придется передавать в теле запроса (POST).
Подробнее об XDomainRequest и его возможностях читать тут — <http://blogs.msdn.com/b/ieinternals/archive/2010/04/06/comet-streaming-in-internet-explorer-with-xmlhttprequest-and-xdomainrequest.aspx?PageIndex=1> )
Браузер Firefox позволяет обрабатывать сообщения с сервера по мере их поступления через стандартный XMLHttpRequest (см. статью [javascript.ru/ajax/comet/xmlhttprequest-interactive](http://javascript.ru/ajax/comet/xmlhttprequest-interactive))
Поэтому он также поддерживает «server-push».
Для остальных же браузеров, можно организовать получение сообщений по схеме long-polling с помощью XMLHttpRequest (т.е. с сервера нам необходимо для таких браузеров разрывать соединение после каждого отправленного сообщения).
Итак, готовый EventSource для браузеров, не имеющих его нативной поддержки — <https://github.com/Yaffle/EventSource>.
Зависимостей от библиотек — нет, все что нужно для работы:
#### Проблемы использования server-push и long-polling
Браузеры ограничивают кол-во одновременных соединений, что при открытии сайта в нескольких вкладках браузера может вызывать проблемы. Конечно, в современных браузеров число соединений ограничено минимум шестью, но если каждая вкладка с вашим сайтом использует 2 или более длинных http-соединения, то этот предел быстро достигается.
Для решения этой проблемы как нельзя лучше подходит SharedWorker, создав SharedWorker мы можем создать внутри него EventSource и рассылать все события с объекта EventSource всем подключившимся скриптам:
Пример, sharedworker.js:
`var es = new self.EventSource('events'),
history = [];
es.addEventListener('message', function (e) {
history.push(e.data);
}, false);
self.onconnect = function onConnect(event) {
var port = event.ports[0]; // отсылаем все полученные ранее сообщения
history.forEach(function (data) {
port.postMessage(data);
});
es.addEventListener('message', function (e) {
port.postMessage(e.data);
}, false);
}`
Но, к сожалению, SharedWorker поддерживается только браузерами Opera 10.6+ и Chrome(Safari). При этом Opera не имеет объекта EventSource «внутри» SharedWorker (т.е. в SharedWorkerGlobalScope). Поэтому данный метод избежания нескольких соединений применим только для Webkit браузеров. Для всех остальных браузеров нам придется завести отдельный домен. Т.к. EventSource не поддерживает кросс-доменных запросов, я предлогаю подключать через iframe html-страницу, находящуюся на домене для EventSource, которая будет «запускать» EventSource и передавать сообщения через «postMessage» (недавно была статья на эту тему — <http://habrahabr.ru/blogs/javascript/120336/>, в которой описано использование библиотеки easyxdm, но «window.postMessage» поддерживается достаточно хорошо современными браузерами (<http://caniuse.com/#search=postmessage>).
#### Last-Event-ID
Когда Соединение с сервером разрывается (либо сервер закрыл соединение, либо произошла какая-то ошибка сети), EventSource выполняет повторное подключение через определенное время(это время можно контролировать). При этом новое подключение будет содержать в заголовке Last-Event-ID — идентификатор последнего полученного сообщения.
Рассмотрим пример ответа сервера — event stream:
*retry: 1000\n
id: 123
data: hello world\n\n*
Поле `*retry*` указывает серверу через какое кол-во милисекунд выполнять переподключение в случае разрыва соединения. Поле `*id*` будет передано в заголовке Last-Event-ID при переподключении. Поэтому с серверной стороны мы можем легко определить идентификатор последнего полученного пользователем сообщения и передать все накопившиемся после него. Пользователь получит все сообщения, ничего не пропустив. Для простоты в примере, отправка сообщения происходит методом GET без аутентификации и защиты от CSRF. Время в чате — местное для сервера, сорри.
Пример чата: <http://hostel6.ru:8002>
Исходники чата можно скачать тут: <https://github.com/Yaffle/EventSource>
Всем Спасибо за внимание!
UPD: Добавлена поддержка CORS для IE8+, FF4-5 | https://habr.com/ru/post/122783/ | null | ru | null |
# Проброс DLNA в удаленную сеть
**Предыстория**:
Итак, появилась необходимость дать возможность просматривать фильмы с моего сервера на телевизоре. Ну казалось бы, поднимаем DLNA, например miniDLNA и проблема решена. Так и было, пока не появилась нужда дать такую же возможность родителям, которые живут в другом месте, и ставить им там сервер или простенький nas не хотелось. Было принято решение объединить наши сети путем туннелирования трафика и дать доступ к моей фильмотеке.
**Подготовка**:
У родителей я уже давно поставил отличный роутер, с которым я давно работаю и доверяю — Mikrotik 951Ui 12HnD. Кто не знаком с этим великолепным маршрутизатором, советую познакомиться. Ценовая политика позволяет подобрать решения как для дома, так и для офиса. При этом получаем функционал, как у дорогих enterprise решений.
У меня в квартире так же стоял Mikrotik, лишь с одним отличием, у меня были все порты гигабитные. Я не долго думая поднял pptp туннель и тут началось…
**Первые проблемы**:
В отличии от классического способа передачи потокового аудио и видео сегмента данных DLNA несколько отличается. И это сразу стало понятно, после того как я посниффил трафик.
1. Все общение между медиа сервером и телевизором происходит по протоколу HTTP
2. Телевизор делает мультикаст рассылку SSDP пакетов на адрес 239.255.255.255.250, в которой регистрирует себя как сервис перед лицом медиа серверов.
3. DLNA сервера при виде нового сервиса начинают обращаться к телевизору напрямую, после пары пакетов отправляет свою информацию внутри
**XML**
```
xml version="1.0" encoding="utf-8"?
1
0
DMS-1.50
M-DMS-1.50
av-upload,image-upload,audio-upload
smi,DCM10,getMediaInfo.sec,getCaptionInfo.sec
smi,DCM10,getMediaInfo.sec,getCaptionInfo.sec
urn:schemas-upnp-org:device:MediaServer:1
[PC]DESKTOP-SBP6BH3
Samsung Electronics
http://www.samsung.com/sec
Samsung PC DMS
PC
AllShare1.0
http://www.samsung.com/sec
uuid:0d1cef00-0032-1000-8823-f46d043e5ae2
H3CJEO6BEFKMU
image/jpeg
48
48
24
/smp\_2\_
image/jpeg
120
120
24
/smp\_3\_
image/png
120
120
24
/smp\_4\_
image/png
48
48
24
/smp\_5\_
urn:schemas-upnp-org:service:ConnectionManager:1
urn:upnp-org:serviceId:ConnectionManager
/smp\_7\_
/smp\_8\_
/smp\_9\_
urn:schemas-upnp-org:service:ContentDirectory:1
urn:upnp-org:serviceId:ContentDirectory
/smp\_10\_
/smp\_11\_
/smp\_12\_
```
4. После того, как вы выбрали медиа файл, который хотите прослушать\посмотреть начинается обмен по TCP, как я понимаю телевизор начинает кешировать медиа файл.
Через PPTP некоторые из этих запросов пробегали, некоторые нет. После того как я изучил дамп трафика, пришел к следующим выводам:
* Со стороны сервера мы должны увеличить ttl трафика от DLNA сервера, ибо по умолчанию ttl=1. (Это необходимо только для SSDP трафика)
* Установить пакет multicast на микротики, и включить PIM на интерфейсы туннеля.
* Не забываем прописать маршруты до локальных сетей за туннелями.
* Со стороны сервера DLNA прописываем маршрут 239.255.255.250 в качестве шлюза указываем туннельный интерфейс.
Казалось бы, все предусмотрел, я на телевизоре родителей увидел свой DLNA сервер, подключился к нему, открыл фильм, и тут я успел увидеть 2 кадра и все. Он просто отключился от сервера. Я начал заново, пробежался по всей конфигурации на обоих маршрутизаторах, грешил на фаервол. Потом опять взглянул на дамп трафика и увидел то самое..**don't fragment**
И тут меня осенило! Размер пакета превышает MTU, который нам предоставляет PPTP, а фрагментировать нельзя! К сожалению в настройках miniDLNA сервера я не смог найти возможность ограничить длину пакета.
**Победное решение**:
В итоге самый простой IP-IP туннель предоставляет нам нужный MTU, MRU, и MSS, но сталкиваемся с проблемой динамической адресации от провайдера, если у вас на обоих концах статика, вам повезло!
Еще можно попробовать ограничить mtu на интерфейсе, к которому подключен NAS. В таком случае пакеты будут заведомо с небольшим MTU, который пролезет в любой туннель, но это может существенно нагрузить CPU.
**Дополнение**:
Не стоит забывать что просмотр фильмов — это нехилая нагрузка на сеть в плане ширины канала. Когда в пределах локальной сети, не страшно, а вот между сетями, когда ширину канала контролирует провайдер… В общем всем советую включить QoS, отдать приоритет своему серверу, и любым подключениям к нему, а мы можем и подождать дополнительных 30 мс для открытия странички.
Если будут пожелания, опишу детально как настраивать Mikrotik.
Статьи, которые я использовал:
[ru.wikipedia.org/wiki/DLNA](https://ru.wikipedia.org/wiki/DLNA)
[ru.wikipedia.org/wiki/Maximum\_transmission\_unit](https://ru.wikipedia.org/wiki/Maximum_transmission_unit)
[wiki.mikrotik.com/wiki/Manual](http://wiki.mikrotik.com/wiki/Manual):Routing/Multicast
Уважаемые! Если вы минусуете статью, пожалуйста, напишите в комментариях почему, и я улучшу ее!
Буду рад критике и замечаниям! | https://habr.com/ru/post/267149/ | null | ru | null |
# Инструкция: как расширить файловую систему в Linux. Часть 1
Чаще всего задача расширить файловую систему возникает при работе с облачной инфраструктурой. Виртуализация позволяет экономить на дисковом пространстве и выделять его столько, сколько необходимо в конкретный момент. Но простого расширения ресурсов недостаточно, об изменениях необходимо сообщить операционной системе. Сегодня ведущий архитектор #CloudMTS Дмитрий Фисенко в формате пошагового туториала расскажет, как это сделать.
Материал будет интересен начинающим системным администраторам, а также разработчикам, которые хотят ближе познакомиться с файловыми системами.
Подготовительная работа
-----------------------
Мы рассмотрим сценарии с двумя вариантами разметки диска — с использованием LVM и логических разделов, а также без них. Поскольку мы будем работать в облачной среде, где важны доступность и непрерывность сервисов, сфокусируемся на подходах, позволяющих расширить файловую систему без перезагрузки виртуальной машины (хотя сделать это не всегда возможно).
В рамках руководства нам также потребуется утилита growpart. К сожалению, нельзя просто так взять и расширить смонтированную файловую систему. Стандартные утилиты вроде [fdisk](https://ru.wikipedia.org/wiki/Fdisk) или [GParted](https://gparted.org/) предлагают предварительно размонтировать раздел. Вот команды установки growpart для различных семейств Linux-систем:
```
apt-get install cloud-utils-growpart
yum install cloud-utils-growpart
dnf install cloud-utils-growpart
```
Также рекомендуем сформировать на виртуальной машине точку восстановления (snapshot) на случай, если что-то пойдет не по плану.
Когда нет LVM
-------------
Рассмотрим задачу, когда на диске присутствует два раздела — загрузочный и корневой. Они смонтированы в произвольную точку. Вот как это выглядит в графическом интерфейсе GParted:
Расширять будем корневой раздел. Первым делом необходимо увеличить доступный объем жесткого диска через панель управления [облачной инфраструктурой](https://cloud.mts.ru/?utm_source=habr.com&utm_medium=owned_media_linux&utm_content=article&utm_term=linux) #CloudMTS — с 7 до 8 Гбайт.
Увеличение диска займет какое-то время, а мы вернемся на тестовый стенд. Отобразим структуру разделов с помощью команды:
```
parted /dev/sdb/ print free
```
Параметры `print` и `free` отвечают за отображение структуры разделов и неразмеченного пространства.
Мы увеличили объем диска, но все равно не видим в выдаче команды `parted` свободную память. Можно перезагрузить сервер, но мы решили, что по возможности не будем останавливать виртуальную машину. Вместо этого, выполним команду:
```
echo 1 > /sys/block/sdb/device/rescan
```
Если мы попытаемся снова отобразить структуру разделов командой `parted`, то увидим предупреждение. Мы используем таблицу разделов в формате GPT. Информация о ней хранится в начале и в конце диска (для резервирования). Когда мы увеличили объем физического накопителя, сменился конец адресного пространства. Система предлагает автоматически переместить резервные файлы. Соглашаемся и пишем в командной строке fix.
Появилось свободное дисковое пространство в размере одного гигабайта:
Прежде чем перейти к расширению файловой системы, необходимо разметить новое пространство и расширить сам раздел. Здесь нам пригодится утилита growpart — выполним команду:
```
growpart /dev/sdb 2
```
Мы расширили раздел, но файловая система осталась нетронутой. Вот как это выглядит в GParted:
Давайте расширим ФС командой `resize2fs`. Если у вас xfs, то нужно указывать точку монтирования. В случае с ext2, ext3 и ext4 достаточно выполнить команду с указанием блочного устройства, которое монтируется в файловую систему. Мы используем ext4, поэтому выполним:
```
resize2fs /dev/sdb2
```
Таким образом, мы успешно расширили файловую систему до размера диска.
Теперь рассмотрим другую ситуацию, когда ФС находится в логическом диске, созданном в расширенном разделе. Так структура выглядит в древовидном формате:
У нас два основных раздела — sdc1 и sdc2. Второй — расширенный, и внутри него можно сформировать неограниченное количество новых разделов. Перейдем в облачную панель управления и увеличим диск на один гигабайт, а затем обновим информацию об устройстве sdc уже известной командой:
```
echo 1 > /sys/block/sdс/device/rescan
```
Конкретно этот диск мы разметили в формате MBR, поэтому здесь мы не видим предупреждений о переносе резервной копии таблицы разделов, как в случае с GPT.
Вернемся в консоль и отобразим информацию о диске:
```
parted /dev/sdb/ print free
```
Чтобы не захламлять выдачу, временно уберем отображение свободного пространства на диске:
```
parted /dev/sdb/ print
```
У нас есть три раздела: основной под номером один, расширенный и логический под номерами два и пять.
Чтобы понять, какие разделы находятся в extended, необходимо сверить их начало и конец. Здесь мы видим, что конец второго раздела соответствует концу пятого раздела — 5369 Мбайт. И размер последнего на один мегабайт меньше. Так мы можем утверждать, что пятый раздел находится во втором разделе.
Чтобы расширить пятый раздел, необходимо предварительно увеличить второй. Для этого выполним:
```
growpart /dev/sdc 2
```
Вот так результат команды будет выглядеть в графическом отображении:
Раздел extended был расширен до конца всего раздела — вокруг неразмеченной области появилась голубая рамка. Теперь расширим пятый раздел, который пока занимает 4,5 Гб из доступных 5,5 Гб. В консоли пишем:
```
growpart /dev/sdc 5
```
Теперь и желтая рамка, обозначающая пятый раздел, протянулась до конца физического диска. Но мы видим, что файловая система все еще заканчивается сильно раньше. В нашем примере мы используем файловую систему xfs, которая наиболее распространена на CentOS, хотя иногда её применяют и на Debian с Ubuntu.
Для расширения файловой системы выполним команду:
```
xfs_growfs /mnt/sdc5
```
Обратите внимание, что в случае с `xfs` мы указываем не само физическое устройство, а точку монтирования. В нашем случае это `/mnt/sdc5`, но в частном случае это будет корень.
Вновь обращаемся к GParted и видим, что файловая система расширена до конца.
Если есть доп. разделы
----------------------
Рассмотрим ситуацию, когда после расширяемого раздела идут другие — SWP, Home, Data и так далее.
В случае SWP облачная инфраструктура предлагает выход из ситуации. Мы можем выделить операционной системе столько памяти, чтобы ей вообще не приходилось применять своп. Затем раздел можно отключить из автозагрузки и удалить, а освободившееся дисковое пространство присоединить к целевому.
Есть и другой вариант, позволяющий сохранить SWP. С точки зрения виртуальной машины диск представляет собой файл в системе хранения данных с разными расширениями — например, VDI или VHDX. Мы можем изменить локацию SWP на файл в файловой системе, которую планируем расширять. Мы не будем говорить о переносе SWP в файл, так как это выходит за рамки нашего материала. Однако в интернете можно найти подробные руководства — вот [одна из таких инструкций](https://linuxthebest.net/kak-ispolzovat-swap-fajl-vmesto-swap-razdela-v-linux/).
Если вместо SWP за целевым разделом следует раздел с данными, ситуация становится интереснее. К сожалению, в этом случае нельзя расширить файловую систему без простоя. Поэтому на реальной инфраструктуре лучше запланировать технологическое окно в вечернее время.
Для решения задачи мы воспользуемся GParted Live CD — скачать его можно [на официальном сайте](https://gparted.org/livecd.php). Переходим на вкладку Download и загружаем образ.
Подключаем образ к виртуальной машине. Последовательность действий зависит от конкретной системы виртуализации. Загружаемся с диска и видим уже привычный графический интерфейс для расширения файловой системы. Как обычно, начинаем с увеличения доступного объема диска в панели управления облаком.
В этом примере разделом с данными выступает linux-swap. Обновляем информацию по разделам в консоли:
```
echo 1 > /sys/block/sdd/device/rescan
```
Затем — информацию в графическом интерфейсе. Видим неразмеченное дисковое пространство объемом в один гигабайт.
Расширим раздел extended до максимального размера. Для этого правой кнопкой мыши вызываем выпадающее меню и выбираем пункт Resize/Move.
Откроется новое всплывающее окно, в котором необходимо подвинуть ползунок в крайнее правое положение. И подтвердить операцию.
Далее открываем меню Resize/Move для раздела с данными — в нашем случае это linux-swap.
Мышкой перемещаем красную рамку в конец жесткого диска, подтверждаем операцию.
Теперь на главном экране раздел linux-swap находится в конце блока extended.
Далее остается произвести расширение целевого раздела и файловой системы.
В верхней части экрана нажимаем кнопку Apply All Operations.
Спустя какое-то время утилита применит все изменения.
У такого подхода есть одна серьезная проблема. Если раздел linux-swap довольно объемный, то его перемещение в конец диска может занять два-три часа. Все это время приложения и сервисы виртуальной машины будут простаивать. Вопрос можно решить, если сформировать в виртуальной инфраструктуре несколько дисков под каждый раздел. Так вы всегда сможете расширить условные /data и /root, поскольку они будут независимы друг от друга.
Другим решением, которое позволит избежать простоев, является разметка диска с помощью LVM.
Если есть LVM
-------------
К сожалению, для работы с LVM нет нормальных программ с графическим интерфейсом. Точнее, они есть, но не слишком информативные. Так с логическими томами приходится работать исключительно в командной строке.
В контексте LVM существуют физические тома (physical volume) — это целые неразбитые диски или их разделы. Внутри физических томов также есть разделы, объединённые в volume-groups. Эти группы, в свою очередь, дробятся на логические разделы — еще один уровень абстракции.
Что нам это дает? Рассмотрим два варианта разметки разделов диска. Чисто технически они ничем не отличаются — первый загрузочный, а второй физический том с LVM. В последнем случае он уже разбит на дополнительные разделы.
Может быть и следующая картина. Два раздела лежат в extended partition, а третий стоит отдельно, но добавлен в volume group. На отдельном диске дополнительно выделен раздел и также добавлен в эту группу.
Дополнительный уровень абстракции LVM позволяет нам расширять файловую систему вне зависимости от порядка разделов и предоставляет несколько подходов. Например, можно просто увеличить объём раздела, а можно создать новый и «приписать» его в логическую группу. Главное не переборщить с дроблением, чтобы разметку было проще читать.
*Небольшая ремарка — если на диске есть раздел, который монтируется как блочное устройство и не участвует в LVM, то при расширении могут возникнуть проблемы. Здесь нужно или подключать образ Live CD, или перемещать раздел на отдельный виртуальный диск — тогда он не будет мешать увеличивать основной и логические разделы и volume groups.*
Перейдем непосредственно к расширению файловой системы с LVM. На нашем тестовом стенде есть диск /dev/sde со следующей структурой:
В панели управления облаком увеличим объем диска на один гигабайт. Отобразим информацию о нем в консоли:
```
echo 1 > /sys/block/sdd/device/rescan
parted /dev/sde/ print free
```
Мы видим, что у нас добавилось свободное дисковое пространство.
Разделы, использующие LVM, помечены соответствующим тегом. В этом конкретном примере мы будем увеличивать диск под номером три до необходимого нам объёма. Нам не придется ставить дополнительные утилиты, так как все инструменты по умолчанию присутствуют во всех популярных дистрибутивах Linux.
Мы воспользуемся возможностями `parted`. Но предварительно отобразим размер свободного пространства в мегабайтах для наглядности.
```
parted /dev/sde unit MB print free
```
Далее смотрим на ключевые столбцы — Start, End и Size. Свободное дисковое пространство заканчивается на точке в 6442 Мбайта.
Чтобы расширить последний раздел, прописываем команду:
```
parted /dev/sde resizepart 3 6441MB
```
Обратите внимание, что мы уменьшили цифровое значение в конце на один мегабайт. Проверим внесенные изменения:
```
parted /dev/sde print free
```
Свободное дисковое пространство уменьшилось до одного мегабайта, а наш второй раздел имеет объем в 3806 Мбайт.
Вернемся в GParted и обновим информацию по разделам. Сейчас LVM в /dev/sde3 не «растянут» до конца.
Посмотрим на объем текущего физического тома – для этого выполним:
```
pvdisplay
```
Как физические тома у нас помечены два устройства — sde2 и sde3. Последний имеет объем в 2,5 Гб, но в GParted эта цифра равна 3,5 Гб. Чтобы исправить ситуацию и синхронизировать значения, нужно выполнить команду:
```
pvresize /dev/sde3
```
Повторяем `pvdisplay` и видим, что объем физического раздела увеличился.
Визуальное отображение в GParted также изменилось:
Чтобы отобразить существующие логические разделы, обратимся к команде:
```
lvscan
```
В нашей группе томов присутствуют два логических раздела — root и data.
Мы можем увеличить любой из этих томов. Для примера расширим /root следующей командой:
```
lvextend /dev/vg/root -l +100%FREE -r
```
Ключ -r автоматически расширит и раздел, и файловую систему внутри него (как в случае с xfr, так и с ext). Переходим в GParted и видим, что операция выполнена успешно:
Теперь, если прописать в консоли `df -h`, мы увидим, что устройство dev/mapper/vg-root имеет объем в два гигабайта, хотя изначально его объем был равен одному гигабайту.
Как определить разметку
-----------------------
Поговорим о том, как понять, какая разметка у нас используется — с LVM или без? Если после выполнения команды `df -h` вы видите исключительно устройства типа /dev/sda — блочные устройства — то разметка выполнена без LVM. Также можно ввести команду `lvscan`. Если LVM не используется, то она ничего не отобразит. В противном случае покажет используемые логические разделы. На изображении ниже их два — root и data.
Иногда консоль может отобразить достаточно экзотические варианты, когда используется не dev, а dm0, dm1 и так далее. Чтобы понять, что это за устройства и какие логические разделы следует расширять, можно воспользоваться следующей командой. Она выведет всю информацию об устройствах.
```
lsblk --output NAME,KNAME,TYPE,SIZE,MOUNTPOINT
```
Например, мы видим, что dm-0 смонтирован в /mnt/sde-vg-root. Достаточно часто этот путь указывает в корень. И есть еще одна команда:
```
ls /dev/dm-*
```
Она отображает все устройства вида dm-\*. Как видно на скриншоте ниже, в нашем случае их два.
Пока на этом всё. В следующей части поработаем с реальной виртуальной машиной на операционной системе Linux Mint.
**P.S.** Продолжается [акция](https://cloud.mts.ru/promo/iaas/?utm_source=habr.com&utm_medium=owned_media_iaaslinux&utm_content=article&utm_term=akc) при запуске ИТ‑инфраструктуры IaaS c #CloudMTS.
[](https://cloud.mts.ru/promo/iaas/?utm_source=habr.com&utm_medium=owned_media_iaaslinux&utm_content=article&utm_term=akc) | https://habr.com/ru/post/679176/ | null | ru | null |
# Выявление скрытых зависимостей в данных для повышения качества прогноза в машинном обучении
План статьи
-----------
1. Постановка задачи.
2. Формальное описание задачи.
3. Примеры задач.
4. Несколько примеров на синтетических данных со скрытыми линейными зависимостями.
5. Какие ещё скрытые зависимости могут содержаться в данных.
6. Автоматизация поиска зависимостей.
* Число признаков меньше пороговой величины.
* Число признаков превышает пороговую величину.
Постановка задачи
-----------------
Нередко в машинном обучении встречаются ситуации, когда данные собираются априори, и лишь затем возникает необходимость разделить некоторую выборку по известным классам. Как следствие часто может возникнуть ситуация, когда имеющийся набор признаков плохо подходит для эффективной классификации. По крайней мере, при первом приближении.
В такой ситуации можно строить композиции слабо работающих по отдельности методов, а можно начать с обогащения данных путём выявления скрытых зависимостей между признаками. И затем строить на основе найденных зависимостей новые наборы признаков, некоторые из которых могут потенциально дать существенный прирост качества классификации.
Формальное описание задачи
--------------------------
Перед нами ставится задача классификации L объектов, заданных n вещественными числами. Мы будем рассматривать простой двухклассовый случай, когда метки классов — это −1 и +1. Наша цель — построить линейный классификатор, то есть такую функцию, которая возвращает −1 или + 1. ***При этом набор признаковых описаний таков, что для объектов противоположных классов, измеренных на данном множестве признаков, практически не работает гипотеза компактности, а разделяющая гиперплоскость строится крайне неэффективно.***
Иными словами, всё выглядит так, будто задача классификации на данном множестве объектов не может быть решена эффективно.
Итак, мы имеем столбец ответов, содержащий числа -1 или 1, и соответствующую ему матрицу значений признаков X1…Xn, состоящую из L строк и n столбцов.
Мы ставим перед собой подзадачу найти такие зависимости F(Xi,Xj), которые бы могли выступить в роли новых признаков для классифицируемых объектов и помочь нам построить оптимальный классификатор.
Примеры задач
-------------
Давайте рассмотрим нашу задачу по нахождению функций F(Xi,Xj) на примерах. Разумеется, весьма жизненных.
Примеры будут связаны с лепреконами. Лепреконы, если кто не в курсе, существуют где-то рядом с нами, хоть их практически никто и не видел. И у них, как и у людей, есть свои компьютеры, интернет и соцсети. Большую часть времени они посвящают поискам золота и складированию его в свои мешки. Однако же помимо честных лепреконов попадаются и такие, которые пытаются отлынить от этой важной работы. Их называют лепреконами-диссидентами. И именно из-за них скорость прироста объёмов золота у лепреконов никак не может достигнуть нужной величины!
Так как в мире лепреконов так же есть машинное обучение, их научились находить исходя из их поведения в крупных соцсетях. Но есть проблема! Каждый год появляется много молодых соцсетей, пытающихся захватить рынок, но ещё не умеющих собирать достаточно данных о своих пользователях для анализа! А тех данных, что они собирают, ну никак не достаточно, чтобы отличить порядочного лепрекона от лепрекона-диссидента! И тут то мы и сталкиваемся с необходимостью искать скрытые зависимости в имеющихся признаковых описаниях, чтобы на основе недостаточных на первый взгляд данных суметь построить оптимальный классификатор.
Однако пример с соцсетями будет вероятно чересчур сложным для разбора, так что давайте попробуем решить подобную задачу на примере ядерных процессоров лепреконов. Они характеризуются 4мя основными признаками:
a) Скорость вращения реактора (млн об/сек)
b) Вычислительная мощность (трл вычислений/сек)
c) Скорость вращения реактора под нагрузкой (млн об/сек) и
d) Вычислительная мощность под нагрузкой (трл вычислений/сек)
Ядерные процессоры производят 2 основные фирмы: 0 и 1 (‘Black Zero’ и ‘The First’). При этом у Black Zero цены вдвое ниже, но и ресурс также ниже впятеро! Однако главный гос. поставщик ядерных процессоров постоянно пытается обмануть заказчика и вместо оплаченных машин фирмы The First поставить более дешёвые и ненадёжные машины фирмы Black Zero. При этом разброс рабочих параметров реакторов настолько велик, что по основным характеристикам отличить одни от других для большинства измерений невозможно. В таблице 1 приведены характеристики 50ти случайно выбранных машин для каждой из фирм:
*Таблица 1*
Для удобства сравнения объекты классов 1 и 0 расположены не вертикально, а сбоку друг относительно друга. В приведённом примере видно, что в целом параметры вычислительной мощности зависят от оборотов реактора, причём, для машин разных производителей зависят несколько по-разному: для машин Black Zero в сравнении с машинами The First число вычислений выше при нормальных условиях для схожих оборотов реактора, но ниже под нагрузкой. Конечно, это потому, что машины фирмы The First без нагрузки входят в режим экономии плазмы, следствием чего является небольшое снижение производительности. Зато под нагрузкой они явно опережают конкурента.
Вот только мы видим эту зависимость, потому что данные специально так подобраны, чтобы эта зависимость была видна. В реальности же среди многих тысяч измерений и десятков (если не сотен) признаков, которые не могут быть так красиво отсортированы, как в этом придуманном примере, увидеть глазами такого рода зависимости обычно просто невозможно. А если ещё и не до конца ясна вся бизнес-специфика каждого признака, то пытаться найти глазами такие закономерности – занятие как минимум низкоэффективное.
Поэтому то, двигаясь в рамках парадигмы автоматизации обучения алгоритма, нам бы хотелось по максимуму исключить из процесса нахождения зависимостей между признаками человеческий фактор. Давайте рассмотрим несколько вариантов скрытых зависимостей и подумаем, как лучше всего организовать процесс их обнаружения.
Несколько примеров на синтетических данных со скрытыми линейными зависимостями
------------------------------------------------------------------------------
#### Вариант зависимости 1. Xj = K\*Xi + C, K = 1
Первый вариант зависимости говорит: j-тый признак объекта линейно зависим от i-того признака, а также от свободного члена, представленного константой.
В нашем узком примере коэффициент пропорциональности будет равен единице, чтобы лучше можно было увидеть вклад свободного члена.
Пусть b = a — 1, d = c – 1.1 для класса 0 и наоборот для класса 1 (b = a – 1.1, d = c – 1)
В данном случае, конечно же, очевидно, что новый столбец со значениями
(d – b)
даст для объектов 0-го и 1-го классов соответственно значения
(c – 1.1) – (a – 1) = **c – a – 0.1**
и
(c – 1) – (a – 1.1) = **c – a + 0.1**
соответственно. А это, в свою очередь, при однородности данных в колонках A и C (а это одно из условий в нашей задаче), даёт нам неплохой инструмент для разделения объектов. И мы как минимум можем рассчитывать на позитивный вклад данного нового столбца в итоговую классификацию.
Результат подобного вычисления на наших придуманных данных вы можете посмотреть в таблице 2:
*Таблица 2*
Подобная ситуация, несмотря на кажущуюся надуманность, в действительности имеет место быть в жизни. Примером может служить необходимость для реализации некоего условия выполнить ряд регламентированных действий, имеющих константный набор сайд-эффектов. В случае с ядерными процессорами в нашем примере константная деградация вычислительной мощности может быть связана с необходимостью запуска фиксированного процесса для выхода на работу под нагрузкой. В жизни – запуск дополнительного генератора, фиксированное выделение ресурсов в резерв, энергия для запуска ДВС или промышленного генератора на ТЭС и т.д.
Однако выбор именно данной функции F(d, b) в реальной задаче конечно же не будет очевидным. Поэтому давайте рассмотрим для начала, к каким результатам приведёт нас иной выбор F(Xi, Xj)
`F(Xi, Xj) = Xi/Xj`
Говоря в терминах признаков нашей задачи, здесь мы можем попытаться измерить например деградацию вычислительной мощности под нагрузкой (B/D). Причём, исходя из предположения, что такая деградация не зависит от константы, а является полностью относительной величиной.
Давайте посмотрим, что получится в результате.
*Таблица 3*
Как можно увидеть в таблице 3, отношения (A/B) и (C/D) информативными не являются. Объекты противоположных классов на них по прежнему сильно перемешаны. А вот отношение B/D ожидаемо делает выборку линейно разделимой. Прямо как и в случае (B – D). Однако, забегая немного вперёд, скажу, что причина данной линейной разделимости по данному признаку всё же несколько иная, нежели для функции разности. Это будет наглядно видно на следующем примере.
Пока же давайте опустим этот нюанс и подумаем, что может быть не так в данном варианте зависимости. Для алгоритма — скорее всего ничего. А вот для человека визуально признаки для обоих классов могут показаться очень близкими. Конечно, в данном примере все значения красиво распределились по разные стороны от единицы, но в жизни такой наглядности может и не быть. Как же решить данную косметическую проблемку? Один из простых вариантов – посчитать прирост значения в числителе относительно величины значения в знаменателе. Что это значит?
Вычисляя отношение (X/Y), мы получаем ответ на вопрос «Сколько раз Y поместится в величину X». Однако же порой выгоднее решить вопрос «Сколько Y-ов нужно прибавить к величине Y, чтобы получился X». Во втором случае мы ищем прирост. Прирост может быть положительным и отрицательным и выражается простой формулой (X/Y – 1). Минус один – потому что за единицу измерения мы берём один Y.
Давайте ещё раз посмотрим в таблицу 3 (на две самые правые колонки) и обратим внимание на то, что теперь мы наглядно видим, что прирост для объектов разных классов есть величина разнознаковая. Стало быть, мы можем говорить о разнонаправленности прироста B от D для разных классов. И именно этот фактор в данном случае в действительности и играет ключевую роль в том, что признак (B/D) делает выборку линейно разделимой. Вывод: каждая из функций: (B – D) и (B/D) (или B/D — 1) делает выборку линейно разделимой несколько иным способом, а значит, возможны ситуации, когда лишь одна из них будет продуктивной для некоторой пары признаков. Но об этом более подробно чуть позже. Сейчас же давайте перейдём к третьей функции – последней для первого примера.
(A/B) / (C/D) – отношение линейных связей
или
(A/B — 1) / (C/D — 1) – отношение приростов
Что может побудить нас считать отношения линейных связей или отношения приростов? В нашем примере двух разных производителей техники такое вычисление имеет следующий смысл: «насколько изменится зависимость производительности от оборотов при подключении нагрузки».
Что ж, вполне законный вопрос. Учитывая, что речь идёт о разных производителях, разное поведение техники при повышении нагрузки вполне ожидаемо. В жизненных же ситуациях мы можем вести речь о том, что есть две взаимосвязи: F(Xi, Xj) и F(Xii, Xjj), и каждая из них в действительности есть функция от неизвестного нам набора параметров: F(M) и F’(M). И если такая гипотеза верна, мы можем предполагать, что даже если каждая из функций F и F’ одинаково проявляет себя для объектов разных классов, их композиция F''(F, F') может проявляться различно на объектах разных классов, так как в действительности у этих разных классов значимо различны неизвестные нам параметры из множества M.
В нашем примере, конечно, мы изначально знаем, откуда растут ноги у такой взаимосвязи второго порядка, так как сами и составляли соответствующим образом данные. В жизни же мы можем этого не знать и рассчитывать лишь на то, что такая взаимосвязь существует. И следовательно пытаться её найти.
Давайте вернёмся к таблице 3 (четыре центральных колонки) и посмотрим, как проявляют себя данные функции для пар (A/B) и (C/D). Мы видим, что обе они делают выборку линейно разделимой. Как и рассмотренные ранее (B – D) и (B/D).
Единственным важным различием в данном примере является то, что значения функции (A/B) / (C/D) лежат весьма близко друг к другу, а вот ширина разделяющей полосы для объектов при использовании функции (A/B — 1) / (C/D — 1) значительно шире. Глядя на такой результат, можно задаться двумя вопросами:
1. Так ли важно это различие?
2. Всегда ли обе функции показывают одинаковую разделяющую способность?
Ответ на первый вопрос: Да, если мы планируем так или иначе включать в композицию метрические методы классификации. Ведь при более широкой разделяющей полосе лучше срабатывает гипотеза компактности. К тому же мы можем вести речь и о качестве визуализации. Справедливости ради стоит, конечно, отметить, что в данном примере метрические методы после обучения всё равно безошибочно разделят выборку по признаку (A/B) / (C/D). Однако в жизни взаимопроникновение при использовании метрики может оказаться куда более существенным.
Ответ же на второй вопрос для данного примера, пожалуй, не является достаточно очевидным. Поэтому давайте оставим его висящим в воздухе до рассмотрения следующего примера.
#### Вариант зависимости 2. Xj = K\*Xi + C, K = 1, C – однознаковый для обоих классов
Данный пример – частный случай первого, в котором свободный член принимает для всех объектов значение либо больше, либо меньше нуля. Посмотрим, к каким эффектам это приведёт.
Пусть b = a — 1 для обоих классов, а вот d = c – 1.2 для класса 0 и c – 1.3 для класса 1)
В данном случае, конечно же, очевидно, что новый столбец со значениями
(B — D) даст для объектов 0-го и 1-го классов соответственно значения
(c – 1) – (a – 1.2) = **c – a + 0.2**
и
(c – 1) – (a – 1.3) = **c – a + 0.3**
соответственно. А это, в свою очередь, при однородности данных в колонках A и C (а это одно из условий в нашей задаче), даёт нам неплохой инструмент для разделения объектов. И мы опять как минимум можем рассчитывать на позитивный вклад данного нового столбца в итоговую классификацию.
Результат подобного вычисления на наших придуманных данных вы можете посмотреть в таблице 4:
*Таблица 4*
Левые 8 колонок — актуальные значения признаков a, b, c, d для классов 0 и 1. Значения в остальных колонках — вычисленные в соответствии с функцией в заголовке. Значения (B — D) в двух правых колонках.
Итак, давайте посмотрим, что даст нам применение уже известных функций, которые в примере 1 смогли сделать выборку линейно разделимой.
`F(Xi, Xj) = Xi/Xj`
Как можно видеть в таблице 4, информативных отношений в данном случае найти не удаётся. И даже отношение (B/D) – колонок, значения в которых вычислены нами разными способами, не даёт нам сколь бы то ни было удовлетворительного результата (5-ая и 6-ая колонки справа). Но в чём же дело? Мы же всего лишь немного изменили значение свободного члена! Причина в том, что в первом примере свободный член для разных классов имел разный знак. И именно это и делало выборку линейно разделимой на признаке (B/D).
(A/B) / (C/D) – отношение линейных связей или
(A/B — 1) / (C/D — 1) – отношение приростов
Напомню, что в нашем надуманном примере про компьютеры лепреконов такое вычисление имеет смысл: «насколько изменится зависимость производительности от оборотов под нагрузкой».
На наших специально подогнанных и отсортированных данных мы невооружённым глазом видим, что деградация производительности под нагрузкой у машин фирмы The First немного выше, чем у машин фирмы Black Zero. (Но почему же тогда они стоят дороже? Очевидно, Black Zero пытается выжать из своих ядерных процессоров больше, чем те могут потянуть, сохранив при этом надёжность. Поэтому то они и служат в пять раз меньше, чем процессоры The First! Негоже жертвовать качеством в угоду маркетингу, Black Zero!)
Ну да вернёмся к нашим взаимосвязям. Если вновь заглянуть в таблицу 4, можно заметить одну очень интересную вещь!
Отношение приростов (A/B — 1) / (C/D — 1) делает выборку линейно разделимой, в то время как отношение линейных связей (A/B) / (C/D) оставляет довольно большой диапазон неопределённости! К слову говоря, вот и ответ на вопрос «Всегда ли обе функции показывают одинаковую разделяющую способность?»
(В таблице 4 это колонки с 7-ой по 10-ую справа. Непересекающиеся значения выделены цветом)
Что ж. Самое время перейти к третьему примеру, а пока просто запомнить следующее:
* функции отношения линейных связей и отношения приростов не всегда показывают одинаковую разделяющую способность;
* в примере, когда разделяющая способность функции отношения приростов была выше разделяющей способности функции отношения линейных связей, также стопроцентную разделяющую способность проявила функция разности, а вот отношения пар признаков были мало информативны для построения оптимального классификатора.
#### Вариант зависимости 3. Xj = K\*Xi + C, K != 1, C = 0
Ещё один частный случай, но в котором в неизвестной зависимости играет роль коэффициент, а не свободный член.
Пусть b = a — 1 для обоих классов, а вот d = (c \* 0.99) для класса 0 и (c \* 0.98) для класса 1)
Результаты вычислений приведены в таблице 5. Рассмотрим их бегло.
*Таблица 5*
Поскольку вклад в зависимость в этом примере вносит именно (и только!) коэффициент, ожидаемо сто процентную разделимость даёт функция отношения F(Xi, Xj) = Xi / Xj. А обратная к приросту (3-я и 4-ая колонки справа) ещё и улучшает визуализацию. Отношение линейных зависимостей вновь показывает результат, отличный от отношения приростов. Причём, опять в худшую сторону.
А вот бывшая в прошлых примерах стабильно информативной функция разности (две правые колонки) на этот раз оставляет довольно широкую зону неопределённости. И примечательно то, что она совпадает с зоной неопределённости функции отношения приростов. Сравните сами (колонки 1, 2 и 9, 10 справа; непересекающиеся значения разных классов выделены цветом).
Какова же будет картина, если вклад внесёт как коэффициент, так и свободный член? Ожидаемо ни одно из рассмотренных нами отношений в отдельности не делает выборку линейно разделимой. Однако диапазоны неопределённости для разных вычисленных колонок включают в себя разные подмножества объектов выборки! Что конечно же значит, что на множестве вычисленных признаков скорее всего возможно построить разделяющую гиперплоскость, на сто процентов разделяющую объекты разных классов.
Давайте на примере данных в таблице 6 рассмотрим, как проявила себя та или иная функция при заданных нами при формировании данных зависимостях:
для класса 0:
`B = A - 1
D = 0,95*B - 0,55`
для класса 1:
`B = A - 1,1
D = 0,965*B - 0,5`
*Таблица 6*
Для вычисленных значений функций от B и D мы видим, что простое отношение, отношение линейных связей, прирост и обратная к приросту дали очень схожие результаты. При этом, как мы помним, в прошлом примере (таблица 5) простое отношение сделало выборку линейно разделимой, тогда как отношение линейных связей оставило весьма широкую зону неопределённости (что, к слову, обусловлено избыточностью применения для ситуации в прошлом примере функции отношения линейных связей).
Также мы видим, что отношение приростов, в отличие от прошлых примеров, разделило выборку хуже отношения линейных связей. А функция разности дала ещё худшую результативность, нежели отношение приростов (напомню, что во всех прошлых примерах их эффективности были одинаковыми). Это говорит о многом.
**Во-первых**, отношение приростов не обязательно должно показывать ту же результативность, что и простая разность.
**Во-вторых**, разные функции могут оставлять зоны неопределённости разной ширины — в зависимости от истинной природы искомой скрытой зависимости.
**В-третьих**, в зависимости от истинной природы искомой скрытой зависимости разные функции могут дать наилучший результат разделения объектов разных классов.
Перед тем, как перейти к тому, какие ещё могут существовать скрытые взаимосвязи и как лучше организовать их поиск, приведу ещё один пример синтетических данных с зависимой колонкой D. Но на этот раз я намеренно не буду приводить истинную функцию D(a, b, c). Взгляните на таблицу 7 и ещё раз убедитесь в верности трёх выводов, приведённых немного выше.
*Таблица 7*
Какие ещё скрытые зависимости могут содержаться в данных
--------------------------------------------------------
В примерах выше мы использовали довольно примитивную линейную зависимость между признаками. Но может ли быть такое, что зависимость будет выражена не линейной функцией, а какой-то иной, более сложной?
Почему бы и нет. Например, представьте себе данные, собираемые датчиками в среде размножения колонии зелёных микроорганизмов. Если предположить, что фиксируется концентрация продуктов жизнедеятельности M, а также ряд объективных физических параметров среды, включая освещённость lx, то мы можем полагать, что присутствует зависимость M(lx). Но линейна ли такая зависимость. Если положить, что освещённость линейно влияет на скорость размножения бактерий, а концентрация ПЖД — линейно зависит от численности колонии, то зависимость должна быть квадратичной. Причина — способ размножения одноклеточных. А именно — деление клеток. Думаю, здесь излишне доказывать, что увеличение скорости деления одноклеточных квадратично (от скорости) повлияет на их численность через время t. Следовательно, мы можем пытаться например вычислить отношение (√M / lx), полагаемое нами как некоторая аппроксимация искомой линейной зависимости скорости размножения зелёных бактерий от освещённости. И если два вида зелёных бактерий и впрямь различаются тем, насколько освещённость влияет на их скорость размножения, то данный новый признак наверняка сможет внести свой полезный вклад в качество итогового алгоритма классификации.
Конечно, зависимости могут быть самыми разными, и в основе лежит смысл, вложенный в тот или иной признак. Однако же давайте уйдём от смысловой нагрузки признаков, которыми описаны объекты выборки, а вместо этого подумаем, как можно автоматизировать процесс поиска скрытых зависимостей.
*Автоматизация поиска зависимостей*
Итак, мы хотим определить, есть ли в нашем признаковом описании скрытые зависимости. Положим, мы решили не искать сложных алгоритмов выбора пар признаков, и просто проверить нашу гипотезу о наличии связи для всего множества признаков N: {X1… Xn}. Начать мы решаем с пар признаков, и для каждой пары вычислить некоторое значение — результат применения для данной пары некоторой функции из множества M: {F1(Xi, Xj)… Fm(Xi, Xj)}. При этом мы полагаем, что функции множества уже отобраны нами с учётом некоторой специфики нашей задачи.
Несложно догадаться, что число пар, для каждой из которых мы хотим применить m функций из множества M, есть число сочетаний из n по 2, то есть:
`n! / (2! * (n - 2)!) = n * (n - 1) / 2 = (n² - n) / 2 = **½ n² - ½ n**`
Видно, что мы имеем дело с асимптотической сложностью **O(n²)**.
А из этого вытекает два вывода:
1. Такой полный перебор допустим только для выборки с числом признаков, не превышающим некоторой пороговой величины, вычисленной заранее.
2. Вычисление зависимостей второго порядка, в которых участвуют уже вычисленные на основе первичных данных колонки (как отношение приростов), допустимо лишь в том случае, если существует строгий алгоритм отбора пар для таких проверок. В противном случае алгоритм полного прохода будет иметь сложность **O(n⁴)**. Хотя в общем случае зависимости второго порядка так или иначе основаны пусть и на порой более слабых, но всё же достаточно информативных зависимостях первого порядка.
Соответственно, из сказанного выше следует, что возможны два случая:
1. Число признаков меньше пороговой величины, и мы можем позволить себе проверку гипотезы на каждой паре.
2. Число признаков превышает пороговую величину, и нам необходима стратегия отбора пар, на которых мы будем полноценно проверять гипотезу.
Рассмотрим сначала первый случай.
*Число признаков меньше пороговой величины*
Строго говоря, для нас не столько важно выявление некоей зависимости само по себе, сколько её разное поведение на объектах разных классов. Поэтому мы можем просто опустить момент проверки на предмет наличия зависимости, а вместо этого сразу провести проверку на предмет полезности новой колонки. Для этого достаточно применить один из известных быстрых классификаторов для данной колонки, измерив среднюю величину интересующей нас метрики качества на скользящем контроле. И затем, если показатель интересующей нас метрики качества выше заданной нами пороговой величины, оставить новую колонку, либо удалить её, если качество не дотянуло до требуемого.
Конечно же, здесь читателю в голову может прийти мысль: а что, если новая колонка вычислена на основе изначального признака, и без того имеющего высокую полезность для итогового алгоритма классификации? Ведь в этом случае получится, что мы просто создали лишний признак, опирающийся на уже имевшийся! Порождение мультиколлинеарности в чистом виде! Так вот именно на это мы и задаём порог метрики качества классификации для производных признаков. Несложно догадаться, что поскольку мы вычисляем функцию от пары признаков (а не от одного!), итог может быть и просто шумом, даже если на входе обе колонки были весьма информативными.
В этом несложно убедиться на примере синтетических данных, где значения в каждом признаке — независимо сгенерированные величины с заданными средней и отклонением. Причём, так, чтобы между средними разных классов было различие, а распределение на объектах каждого класса — нормальное (например, с помощью numpy.random.normal). Так вот поскольку мы априори генерируем значения признаков независимо друг от друга, попытка найти зависимости приводит лишь к зашумлённости, а производные признаки не дают удовлетворительного качества классификации.
Так вот приведённый выше пример говорит в пользу того, что если производный признак оказался информативным, мы можем судить о наличии взаимосвязи.
Пороговую величину для производных признаков можно выбирать разными способами. Либо разом для всей выборки, что явно проще, либо индивидуально для каждой пары. Во втором случае мы можем варьировать значение порога входа в зависимости от показателей интересующих нас метрик качества на каждой из колонок, поданных на вход.
Однако несмотря на кажущуюся логичность второго варианта выбора порога, в нём есть очень неприятный подводный камень. Речь о том, что не совсем верно выбирать в качестве порога величину метрики качества на одном из родительских столбцов. Причина в том, что может случиться и так, что производный признак с несколько более низкой величиной качества будет и впрямь аппроксимацией новой зависимости, и как следствие, может ошибаться на ином, нежели родители, множестве объектов. А это значит, что его включение в множество признаков для анализа может радикально повысить итоговое качество классификации!
Что же касается выбора общего порога входа для всех производных признаков, то здесь на мой взгляд весьма удобно выбрать порог исходя из того, какие значения интересующей нас метрики качества имеют (при применении по отдельности!) исходные колонки. Так, если для простоты примера взять Accuracy, то для его значений на исходных колонках [0.52, 0.53, 0.53, 0.54, 0.55, 0.57, 0.59, 0.61, 0.63] оптимальный порог для производных данных скорее всего будет лежать где-то в районе 0,6 (как показывает практика). Так или иначе, это не столь важно, ведь параметр является обучаемым, а его обучение повысит сложность алгоритма только линейно. При обучении же этого параметра так или иначе можно отталкиваться от плотности распределения Accuracy исходных признаков (Accuracy здесь только потому, что на нём данный пример!).
В принципе, здесь всё просто. Поэтому перейдём ко второму случаю.
Число признаков превышает пороговую величину
--------------------------------------------
Данное условие означает, что мы не можем позволить себе проводить полноценный замер полезности для каждого производного признака. Либо даже больше: не можем позволить себе для каждой пары признаков генерировать производный. Оно и понятно: просто представьте, что признаков у нас тысяча. В этом случае число сочетаний будет равно
`999 * 1000 / 2 = 499 500`
И это ещё умножить на число тестируемых функций!
И даже если наш сервер способен посчитать качество классификации выбранным алгоритмом по отдельно взятому признаку 100 раз в секунду, ждать почти полтора часа, пока отработает алгоритм генерации признаков только для одной из выбранных нами функций — занятие как минимум странное. Хотя, с другой стороны порождающее немало свободного времени =)
Ну да вернёмся к нашим баранам. Как можно решать данную задачу?
Попытка уменьшить число исходных признаков на основе их полезности для классификации может оказаться не лучшей идеей, ведь на примере синтетических данных в первой части статьи было наглядно показано, что производный признак, каждый из родителей которого в чистом виде совершенно непригоден для задачи классификации, при идеальных условиях способен сделать выборку линейно разделимой.
Как же тогда быть? Видимо, вычислять производные признаки всё же придётся, правда, с некоторыми ограничениями.
Во-первых, в зависимости от того, насколько превышен порог по числу исходных признаков, мы можем для оценки полезности производных признаков генерировать их лишь для части исходных объектов выборки. Не буду вдаваться в то, какого размера подвыборки следует брать — на этот вопрос неплохо отвечает математическая статистика.
Во-вторых, оценку полезности каждого производного признака следует проводить по урезанному функционалу. Опять же, в зависимости от степени превышенности порога числа исходных. То есть, если до этого мы использовали для оценки качества производного признака, к примеру, метод k ближайших соседей с урезанным функционалом обучения, то теперь мы можем использовать его же, но с фиксировано заданными параметрами. Или применить для взвешивания полученного набора признаков метод опорных векторов с параметрами по умолчанию, и затем отбросить колонки с весом ниже определённого. Или же для более экстремальных случаев (с количеством исходных признаков) можно просто применить один из статистических критериев, например, простой Q-критерий Розенбаума. К сожалению, применение такого рода критериев не сможет помочь нам отобрать признаки, имеющие перемежающиеся пики в их распределениях плотности вероятности или просто разнонаправлено смещённые медианы.
Например, пусть значения получившегося признака для классов 1 и -1 равны соответственно:
`[9,9,9,9,9,8,8,8,8,8,8,8,8,7,7,7,7,6,6,5,4,3,2,2,1,1,1,1,1,0,0,0,0,0,0,0,0,0]
[9,8,8,7,7,6,6,6,6,6,6,6,6,5,5,5,5,5,5,5,5,5,5,4,4,4,4,4,4,4,3,3,3,3,3,2,2,1,0]`
или (для смещённых средних):
`[1,2,2,3,3,3,4,4,4,4,5,5,5,5,5,6,6,6,6] VS [1,1,1,1,2,2,2,2,2,3,3,3,3,4,4,4,5,5,6]`
Очевидно, что в обоих случаях критерий Розенбаума посчитает, что выборки не различаются вообще. Конечно, в данном случае превосходно сработает критерий Пирсона, так как он предусматривает разбиение на некоторое число непересекающихся интервалов и подсчёт числа значений для каждого интервала в отдельности. Однако при этом критерий Пирсона потребует и больше времени на выполнение, а это именно тот параметр, который мы пытаемся оптимизировать при первом — грубом приближении.
В-третьих, по причине того, что мы допускаем снижение качества оценки полезности производных признаков, мы также немного снижаем порог входа.
Таким образом, мы сравнительно малой кровью избавляемся от внушительного числа самых неинформативных признаков. А вот на оставшихся (опять же, в зависимости от их числа) можем применить методы более качественной оценки полезности признака.
Если подытожить, то мы говорим о деградации качества оценки для первичного быстрого отбрасывания самых неинформативных признаков для последующего более качественного оценивания оставшихся.
Что ж, пора, пожалуй, завершать. Если коротко подытожить всё вышесказанное, стоит отметить следующие моменты.
Выводы
------
* Часто для признакового описания данных в задачах классификации бывает возможно найти скрытые зависимости F(Xi, Xj), которые способны выступить в роли самостоятельных признаков и повысить качество классификации.
* Скрытые зависимости между признаками могут описываться разными функциями, и в разных случаях разные функции могут проявить себя лучше остальных.
* Для автоматизации процесса нахождения скрытых зависимостей стоит изначально выбрать набор функций, адекватность применения которых зависит от специфики задачи.
* Число производных столбцов для анализа равно k\*(n² — n) / 2, где k — число выбранных функций, n — число исходных признаков.
* Для не очень большого числа признаков можно позволить себе полный перебор всех пар с полноценной проверкой полезности для каждого полученного признака.
* Если число исходных признаков превышает некоторую пороговую величину, проверку производных признаков стоит проводить в два этапа: быстрое отбрасывание самых неинформативных производных признаков и последующий более качественный разбор оставшихся. Гипотетически есть возможность вычисления производных признаков F(Xi, Xj) от множества признаков M', которые даст нам применение метода главных компонент на исходное множество признаков M, но встаёт вопрос о том, все ли скрытые зависимости в этом случае могут быть проявлены.
Что ж, на этом на этот раз всё. И да, теперь то уж мы точно сможем помочь лепреконам более эффективно находить диссидентов среди своих сородичей! | https://habr.com/ru/post/339250/ | null | ru | null |
# Управление самобалансирующим роботом EduMip с помощью джойстика PS4 dualshock 4 через ROS
Это простой пример про то, как с помощью ROS можно связать несколько устройств по сети и пересылать данные управления.
Под катом в конце — видеодемонстрация управления роботом с джойстика.
Нам понадобится сам джойстик, можно взять от своей ps4 или купить в магазине. Я купил dualshock 4 v2, первой версии тоже должен работать.
Также нужен блютус на вашем компьютере с ROS, в документации к драйверам рекомендуют usb blutooth адаптеры версии 2.1+. У меня прекрасно заработал со встроенным в ноутбук адаптером. Также можно подключить джойстик и просто usb кабелем.
Затем в Ubuntu c ROS нужно установить [драйвер по инструкции](https://github.com/chrippa/ds4drv).
После установки драйверов и соединения джойстика по блютус, запускаем графическую утилиту jstest-gtk и видим что у нас два джойстика, нам нужен второй, так как на нем есть все кнопки и стики.
Так как по умолчанию ROS работает с joy0, то нам это надо переопределить на joy1:
```
sudo chmod a+rw /dev/input/js1
rosparam set joy_node/dev "/dev/input/js1"
```
Теперь нам нужно соединить это все в единую сеть. Ноутбук с ROS будет master, а EduMip с BeagleBone Blue ROS соединяться по wifi к ноутбуку. Оба устройства находятся в локальной сети wifi роутера.
На вашем ПК установите переменные среды ROS для поиска мастера ros (roscore) на ПК с команд .bashrc (добавьте эти команды в конец вашего файла .bashrc ):
```
“export ROS_MASTER_URI=http://192.168.10.101:11311” <- это сообщает ROS IP-адрес машины, на которой выполняется мастер ros (roscore).
“export ROS_IP=192.168.10.101” <- это сообщает ROS IP-адрес этой машины (вашего ПК).
```
На вашем EduMIP установите переменные среды ROS чтобы он нашел мастер ros (roscore) на ПК с команд .bashrc (добавьте эти команды в конец вашего файла .bashrc ):
```
“export ROS_MASTER_URI=http://192.168.10.101:11311” <- это сообщает ROS IP-адрес машины, на которой выполняется мастер ros (roscore).
“export ROS_IP=192.168.10.102” <- это говорит ROS IP-адрес этой машины (Ваш EduMIP).
```
Осталось только написать программу которая будет читать положение стика с джойстика и отправлять в топик, а робот этот топик читать.
```
// Callback function for joystick pessaged
void joyCallback(const sensor_msgs::Joy::ConstPtr& joy)
{
// X vel driven by left joystick for and aft
command_velocity_twist.linear.x = joy->axes[1];
// heading driven by left joysticj left and right
command_velocity_twist.angular.z = joy->axes[0];
}
// this function gets called at 10Hz to publish the command_velocity array of 2 floats
void timerCallback(const ros::TimerEvent& event)
{
cmd_vel_publisher.publish(command_velocity_twist);
}
```
На вашем ПК вы можете визуально посмотреть nodes и topics, запустив «rqt\_graph»:
Демонстрация управления роботом с помощью джойстика:
**Резюме:** С помощью ROS можно построить систему для работа распределенную на несколько устройств и например большие вычисления производить на основном компьютере, на самом же роботе оставить только то что нужно для быстрого реагирования. На BeagleBone Blue стоит программируемая подсистеме реального времени (PRU‐ICSS).
PRU-ICSS состоит из микропроцессора на двух 32-битных ядрах, имеющих RISC-архитектуру и работающих на частоте 200МГц. Каждое ядро имеет свою область памяти, а также совместную с Linux область памяти, может использовать выводы общего назначения, расположенные на разъемах P8-P9, и формировать прерывания.
Кроме этого установленный на BeagleBone Blue датчик MPU9250 при изменении положения может формировать прерывание на которой можно повесить свою функцию, так собственно и сделано в EduMip.
Если говорить про следующий шаг эволюции то это ROS2, где одним из отличий является DDS (Data Distribution Service) позволяющий построить сеть разных взаимодействующих роботов и устройств на которых ROS не запущен. | https://habr.com/ru/post/413901/ | null | ru | null |
# Интерполяция — мать анимации — Твинеры в Unity
Одним из неотъемлемых элементов игровых приложений, обеспечивающих красочный пользовательский опыт, является анимация. Основным компонентом Unity для анимации является **"Mecanim"**, имеющий более привычное название **"Аниматор"**. Это очень мощный инструмент, позволяющий управлять сложнейшими системами объектов, совместимый со скелетными анимациями, экспортируемыми из 3D-пакетов, с инструментами для работы с IK, смешивания анимаций или частичного их проигрывания. И как только ты уверишься в том, что пробовал в аниматоре все, будь уверен - на следующий день ты найдешь новую функцию, с которой не сталкивался ранее. И это будет та самая функция, которой тебе так не хватало.
Но есть и у этого инструмента слабое место. Все анимации жестко ограничены, они **представляют собой** заранее описанный **сценарий**, который просто воспроизводится на иерархии объектов. Впрочем, это не совсем так. Как уже было отмечено выше, аниматор это чрезвычайно сложный инструмент, во всех его UI можно найти множество кнопочек и настроек, каждая из которых, как ни удивительно, выполняет какую-то функцию. К примеру, **Avatar Mask** позволяет сделать так, что некоторый слой анимации будет управлять отдельными частями тела, и персонаж будет махать рукой сидя на лошади, хотя отдельной такой анимации на Mixamo не нашлось =( Аниматор просто отыгрывает 2 анимации параллельно на тех костях, которые были заданы масками.
А что если нам нужно в процессе анимации двигать объект? Ну конечно, для этого существует волшебная галочка **Root Motion**. Теперь перемещение тела обрабатывается отдельно, мы можем просто переключать состояния, и наш персонаж будет перемещаться так, как это было задано анимацией. Он будет не просто плыть с линейной скоростью, скользя ногами по земле, он будет по-настоящему **шагать**! Если в анимации он хромает, перемещение аватара будет синхронизировано с тем, как его ноги касаются земли. Если карабкается - его перемещения будут соответствовать движениям рук. А если добавить к этому IK и развешать по стене опорные точки, можно заставить его цепляться за хаотично торчащие выступы, как герои из серии Assassin's Creed!
Хорошо, с третьей попытки, постараемся все таки сформулировать мысль таким образом, чтобы не скатиться вновь в дифирамбы очередной функции аниматора. Прокрутив в голове конец первого абзаца как дисклеймер, начнем.
Допустим, нам нужна анимация, которая будет **активно взаимодействовать с окружением**. Например, при контакте с персонажем монетка должна подпрыгнуть, сверкнуть, и улететь в карман нашего героя. То есть, сценарий нашей анимации **зависит от контекста** своего выполнения. Или нам просто **не нужен аниматор** на конкретном объекте. Например, анимируя UI нужно очень постараться, чтобы аниматор не заставлял Canvas перерисовываться на каждом кадре. А также, аниматор ничем не сможет помочь, если мы работаем с **несовместимыми интерфейсами**. Например, если мы захотим сделать анимацию накопления при подсчете очков или двигать вершины меша(Может быть, даже взаимодействуя с окружением! Например, плавно помять корпус авто в точке удара). Здесь нам поможет только **описание логики анимации с помощью кода**. Наконец-то мы подобрались к основной теме данной статьи.
Если вы загуглите слово "**Твинер**", без указания контекста найти что-то может оказаться не так то просто, результат потонет в более релевантных синонимах. Правильным запросом будет **Inbetweening**, сокращенно Tweening. Полная версия термина звучит уже более осмысленно и лучше говорит о сути происходящего.
Англоязычная википедия отсылает нас к старой доброй "аналоговой" анимации, когда промежуточные кадры рисовались на бумаге путем наложения соседних кадров на световом столе и рисования кадра "**посередине**".
Современная цифровая анимация не такая суровая, здесь нам на помощь приходит математика. А конкретно, многодетная мать геймдева - **интерполяция**. Среди 1001 способов ее применений анимация если не самый, то уж точно один из самых весомых. Половина тех самых многочисленных функций аниматора - интерполяция под разным соусом. Это и плавные переходы, и смешивание разных анимаций, и, собственно, твининг. В цифровой анимации, имея 2 состояния сцены, параметры объектов на них можно интерполировать, получив сколько угодно **промежуточных состояний** между начальным и конечным положениями. Благодаря этому, при использовании скелетной анимации не существует предела по FPS. Если на спрайтах отрисовано 60 кадров, их анимация не сможет быть плавнее этого порога. Кость же может повернуться и на сотую, и на тысячную долю градуса. То, как будет выглядеть кадр зависит от того, в какой момент времени происходит отрисовка. И хоть человеческий глаз не способен в полной мере оценить плавность картинки с частотой 240гц, мозг умнейшего из живых существ с легкостью может понять, что такой монитор ему действительно необходим.
Твинер не справа и не слева. Он посерединеДумаю, ни для кого не секрет, что анимации хранятся в памяти не покадрово, в виде бесконечно плотной последовательности значений, для этого используются системы функций, определяющих значение параметра в зависимости от времени. Для гибкости настройки, за очень редкими исключениями, анимации не хранятся в виде чистых функций вроде синусоиды или многочлена. Разве что, в отдельных случаях можно столкнуться с **кривыми Безье**. Но чаще используются **B-Сплайны**. Кривые, построенные по опорным точкам, изгиб каждого фрагмента которых можно изменить меняя значение промежуточных точек. Таким образом можно двигать отдельные точки, и добиваться желаемого результата, не меняя общую картину.
вместо уверенного роста, функция изменила свое значение на интервале, чтобы соответствовать касательной, которая проходит через пару промежуточных точекИтак, мы определились с тем, что твинер это, инструмент, позволяющий описать анимацию некоторых параметров между двумя состояниями. И, как мы поняли выше, есть ряд задач, к решению которых подключать аниматор нецелесообразно или просто невозможно. И у этих задач уже масса решений, убийц друг друга разной успешности. Я не буду вспоминать спойлер, чтобы не провоцировать особо впечатлительных. Все эти инструменты реализуют плюс-минус один набор функций различными способами. Самым удачным из существующих на сегодняшний день решений принято считать [DOTween](http://dotween.demigiant.com/documentation.php). Он хорошо себя показывает в тестах производительности, широко распространен и удобен в использовании. Позволяет инициализировать анимации в виде методов расширения к анимируемым полям поддерживаемого типа и имеет возможность построения цепочек из анимаций, в том числе, с поддержкой ветвления. А еще, это одно из немногих решений, в котором присутствует **единственная необходимая функция** в твинере. Хотя она уже **выглядит не так привлекательно**, как весь синтаксический сахар, за который мы все его так любим. Обратимся к документации DOTween. Приготовьтесь, сейчас будет первая строчка кода в статье про код.
```
transform.DOMove(new Vector3(2,3,4), 1);
rigidbody.DOMove(new Vector3(2,3,4), 1);
material.DOColor(Color.green, 1);
```
Здесь мы видим, что DOTween позволяет вызовом одной функции запустить анимацию того или иного параметра стандартных Unity-компонентов. Очень **просто, удобно и красиво**.
А вот **более эффективный** способ его использования, что отмечают и сами разработчики DOTween в документации. Здесь мы можем обратиться к полям любого типа и описать функцию, по которой должно изменяться их значение с течением времени.
```
// Tween a Vector3 called myVector to 3,4,8 in 1 second
DOTween.To(()=> myVector, x=> myVector = x, new Vector3(3,4,8), 1);
// Tween a float called myFloat to 52 in 1 second
DOTween.To(()=> myFloat, x=> myFloat = x, 52, 1);
```
Но на мой взгляд, **единственный необходимый** и самый полезный способ работы с DOTween выглядит вот так:
```
DOTween.To(MyMethod, 0, 1, duration);
```
Это максимально **абстрактное описание твинера**, позволяющее наглядно и эффективно **описать любую задачу** и, как самые внимательные уже заметили, может существенно сократить сигнатуру до `DOTween.To(duration, MyMethod)` вызываемой функции и **улучшить читаемость кода**. Для большей понятности посмотрим, что может находиться MyMethod:
```
public void MyMethod(float pt){
// Use easing function in tweening
var et = EZ.BackIn(pt);
// Animate scale
label.transform.localScale = Vector3.Lerp(Vector3.zero,Vector3.one,et);
//Animate position
label.transform.localPosition = Vector3.LerpUnclamped(Vector3.down*500,Vector3.zero,et);
// Animate color(linear)
label.color = Color.Lerp(Color.clear,Color.white,pt);
// Animate label value
label.text = Mathf.Lerp(0,totalScore,CubicOut(pt)).ToString("0");
}
```
Проще говоря, вместо того, чтобы **привязываться к конкретным** типам, параметрам и длительности анимации, мы просто вызываем функцию, линейно прогоняя значение ее аргумента от 0 до 1. Внутри нее мы можем использовать [функции плавности](https://easings.net), чтобы некоторые из параметров менялись нелинейно, создавая более динамичную картинку. Например, label из примера пролетит увеличиваясь от нижней границы экрана и остановится в центре с небольшим заносом, цвет будет меняться линейно, а накопление счетчика будет происходить таким образом, чтобы последние цифры тикали дольше, создавая приятный визуальный эффект. Конечно, 3 действия из 4 можно было сделать не менее красиво, а вот чего-то более сложного код уже не будет таким лаконичным. Таким образом, мы создаем очень простую и понятную абстракцию, которую легко читать и комфортно использовать вне зависимости от контекста.
 Как уже сказал, в Dotween есть возможность объявлять цепочки анимаций. После завершения предыдущего твина будет выполняться следующий или разовый Callback, позволяющий сообщить о завершении анимации и отобразить кнопку "Далее"
Здесь проблема DOTween прежняя. Как только мы выходим из зоны комфорта, начинаются бесконечные страдания и нестерпимая боль. Как будет выглядеть подобная цепочка?
```
Sequence mySequence = DOTween.Sequence();
mySequence.Append(transform.DOMoveX(45, 1))
.Append(MyMethod,0,1,duration)
.AppendCallback(MiddleCallback)
.Append(MyMethod1,0,1,duration1).AppendCallback(FinishCallback);
```
А еще где-то должна быть реализация. Я предпочитаю использовать лямбды в описании твинера.
```
DOTween.Sequence()
.Append(transform.DOMoveX(45, 1))
.Append(DOTween.To(pt=>{
},0,1,duration))
.AppendCallback(()=>{
})
.Append(DOTween.To(pt=>{
},0,1,duration1))
.AppendCallback(()=>{
});
```
В целом, вроде бы не так и страшно, но с аргументами после лямбды крайне неудобно работать. Несколько хелперов позволяют найти золотую середину и получить удобный, производительный и гибкий твинер, совместимый с любыми видами объектов. Единственная оговорка в том, что **твинер без использования лямбда-функций можно реализовать куда эффективнее**, храня в отдельных структурах лишь ссылку на изменяемое значение и параметры анимации вместо лямбд, захватывающих контекст. Но мы теряем всю гибкость, так что едва ли игра стоит свеч.
К слову, о захвате контекста. Это больное место всех известных мне твинеров, включая и DOTween. Смена сцены в процессе анимации или уничтожение анимируемых объектов ломает его работу. Issue был открыт в марте 2016, и судя по комментариям, проблема есть по сей день. Вероятно, предполагается, что это настолько очевидно, что здесь даже не нужна защита от дурака. В конце концов, всегда можно подписаться на смену сцены и прерывать их исполнение. Или проверять существование объекта в процессе выполнения, потеряв львиную долю производительности и рискуя создать утечку памяти, захватив в зацикленном твинере ссылку на объект, но не затрагивая при этом выгруженный компонент, откуда мы эту ссылку получили. В этой проблеме кроется одна из главных причин, по которым я использую собственный твинер, и единственная, по которой я взялся его писать.
[EZ](https://github.com/niksok13/EZ) написан в 200 строк кода, включая пустые и комментарии, и работает максимально просто. Основной тип объектов, с которым мы работаем - EZQueue. Он хранит в себе очередь из пар делегат-длительность, и прогресс выполнения текущего делегата. Хост-объект является синглтоном, хранит в себе ссылки на все очереди, разделяя их на 2 категории и производит их выполнение в LateUpdate.
Проблема захвата контекста решается следующим образом: По умолчанию, анимация создается в основной категории, которая очищается при смене сцены. Но если мы анимируем объект, помеченный как DontDestroyOnLoad, при создании твинера мы явно это указываем. В таком случае он попадет во вторую группу и не будет выгружен при смене сцены. Интерфейс заточен под использование линейной интерполяции, и поэтому выглядит следующим образом:
```
public EZQueue Tween(float duration, Action action);
public EZQueue Tween(Action action) => Tween(0.3f, action);
public EZQueue Call(Action action);
public EZQueue Delay(float duration = 0.1f);
public EZQueue Wait(Func condition);
public EZQueue Loop();
public void Unloop();
public void Kill();
```
Стандартная длительность анимации в 0.3 секунды была подсмотрена в гайдлайнах Material Design и очень хорошо зарекомендовала себя на практике. Это та длительность, при которой анимация заметна, ощущается ее плавность и эффект от Easing-функции, но не заставляет пользователя ждать. Обычно я указываю бóльшую длительность для каких-то особых анимаций, которые сопровождают значимое действие, но для 90% анимаций это аргумент, который удобнее будет скрыть.
Ниже фрагмент кода, позволяющий заанимировать экран победы с показом результата:
```
private EZQueue ez;
private Text label;
private Image buttonNext;
...
ez = EZ.Spawn().Tween(2.5f, pt => {
var et = EZ.BackIn(pt);
label.transform.localScale =
Vector3.Lerp(Vector3.zero,Vector3.one,et);
label.transform.localPosition =
Vector3.Lerp(Vector3.down * 500, Vector3.zero, et);
label.color =
Color.Lerp(Color.clear,Color.white,pt);
label.text =
Mathf.Lerp(0,totalScore,CubicOut(pt)).ToString("0");
}).Delay(1).Add(()=>{
buttonNext.visible = true;
}).Loop().Tween(pt=>{
buttonNext.transform.scale =
Vector3.one + Vector3.one * (0.1f * Mathf.Sin(6.293f * t));
});
...
void OnClickNextButton(){
ez.Kill();
EZ.Spawn(true).Tween(t=>{
// Hide result UI
});
}
```
Эта статья задумывалась ни в коем случае не как сравнение различных реализаций или реклама своей(Которая, хоть и служит мне верой и правдой не первый год, никогда не претендовала на богатый функционал или хорошую производительность. Это наивная реализация очевидного алгоритма). В первую очередь, я хотел поднять проблему излишнего **перехода от общего к частному** в твинерах. Инструменты, которые должны обеспечивать эффективный и плавный переход в пределах интервала, всего лишь прогонять третий аргумент в функции Lerp, соревнуются в том, как много сахара они смогут насыпать в ваши проекты. А **изначально необходимую функциональность** приходится достигать путем двойной конвертации в виде аргументов функции DOTween.To. Спрятав Lerp в черный ящик они, пусть и упростили твинеры для пользования детьми, превратили их в бесполезные игрушки. Впрочем, как мы убедились выше, если очень постараться, DOTween можно использовать по назначению. *И мыши плакали, кололись, но продолжали есть кактус.*
Разумеется, было бы глупо исключать вероятность, что автор не прав, ожидания к твинерам завышены и не в ту степь, поэтому прикрепляю 2 опроса и буду рад вашим историям в комментарий: Что самое необычное вы анимировали с помощью твинера? Свой самый необычный кейс я упомянул в статье: плавная деформация корпуса авто в области коллизии путем перемещения вершин. | https://habr.com/ru/post/572860/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.